Dogcows Code - chaz/homebank/blob - src/ui-tag.c

   1 /*  HomeBank -- Free, easy, personal accounting for everyone.
   2  *  Copyright (C) 1995-2019 Maxime DOYEN
   3  *
   4  *  This file is part of HomeBank.
   5  *
   6  *  HomeBank is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  HomeBank is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty ofdeftransaction_amountchanged
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "homebank.h"
  21
  22 #include "ui-tag.h"
  23
  24
  25 /****************************************************************************/
  26 /* Debug macros                                                             */
  27 /****************************************************************************/
  28 #define MYDEBUG 0
  29
  30 #if MYDEBUG
  31 #define DB(x) (x);
  32 #else
  33 #define DB(x);
  34 #endif
  35
  36 /* our global datas */
  37 extern struct HomeBank *GLOBALS;
  38 extern struct Preferences *PREFS;
  39
  40
  41 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  42
  43
  44 void
  45 ui_tag_combobox_populate(GtkComboBoxText *combobox)
  46 {
  47 GList *ltag, *list;
  48
  49         //populate template
  50         hbtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combobox), 0, "----");
  51         gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0);
  52
  53         ltag = list = tag_glist_sorted(1);
  54         while (list != NULL)
  55         {
  56         Tag *item = list->data;
  57
  58                 DB( g_print(" populate: %d\n", item->key) );
  59
  60                 hbtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combobox), item->key, item->name);
  61                 list = g_list_next(list);
  62         }
  63
  64         g_list_free(ltag);
  65
  66 }
  67
  68
  69 GtkWidget *
  70 ui_tag_combobox_new(GtkWidget *label)
  71 {
  72 GtkWidget *combobox;
  73
  74         combobox = hbtk_combo_box_new(label);
  75         return combobox;
  76 }
  77
  78
  79 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  80
  81
  82 static void
  83 ui_tag_listview_toggled_cb (GtkCellRendererToggle *cell,
  84                gchar                 *path_str,
  85                gpointer               data)
  86 {
  87   GtkTreeModel *model = (GtkTreeModel *)data;
  88   GtkTreeIter  iter;
  89   GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
  90   gboolean fixed;
  91
  92   /* get toggled iter */
  93   gtk_tree_model_get_iter (model, &iter, path);
  94   gtk_tree_model_get (model, &iter, LST_DEFTAG_TOGGLE, &fixed, -1);
  95
  96   /* do something with the value */
  97   fixed ^= 1;
  98
  99   /* set new value */
 100   gtk_list_store_set (GTK_LIST_STORE (model), &iter, LST_DEFTAG_TOGGLE, fixed, -1);
 101
 102   /* clean up */
 103   gtk_tree_path_free (path);
 104 }
 105
 106 static gint
 107 ui_tag_listview_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
 108 {
 109 gint retval = 0;
 110 Tag *entry1, *entry2;
 111 //gchar *name1, *name2;
 112
 113     gtk_tree_model_get(model, a, LST_DEFTAG_DATAS, &entry1, -1);
 114     gtk_tree_model_get(model, b, LST_DEFTAG_DATAS, &entry2, -1);
 115
 116         retval = hb_string_utf8_compare(entry1->name, entry2->name);
 117
 118     return retval;
 119 }
 120
 121
 122 static void
 123 ui_tag_listview_name_cell_data_function (GtkTreeViewColumn *col,
 124                                 GtkCellRenderer *renderer,
 125                                 GtkTreeModel *model,
 126                                 GtkTreeIter *iter,
 127                                 gpointer user_data)
 128 {
 129 Tag *entry;
 130 gchar *name;
 131 #if MYDEBUG
 132 gchar *string;
 133 #endif
 134
 135         gtk_tree_model_get(model, iter, LST_DEFTAG_DATAS, &entry, -1);
 136         if(entry->name == NULL)
 137                 name = _("(none)");             // can never occurs !
 138         else
 139                 name = entry->name;
 140
 141         #if MYDEBUG
 142                 string = g_strdup_printf ("[%d] %s", entry->key, name );
 143                 g_object_set(renderer, "text", string, NULL);
 144                 g_free(string);
 145         #else
 146                 g_object_set(renderer, "text", name, NULL);
 147         #endif
 148
 149 }
 150
 151
 152
 153 /* = = = = = = = = = = = = = = = = */
 154
 155 /**
 156  * tag_list_add:
 157  *
 158  * Add a single element (useful for dynamics add)
 159  *
 160  * Return value: --
 161  *
 162  */
 163 void
 164 ui_tag_listview_add(GtkTreeView *treeview, Tag *item)
 165 {
 166         if( item->name != NULL )
 167         {
 168         GtkTreeModel *model;
 169         GtkTreeIter     iter;
 170
 171                 model = gtk_tree_view_get_model(treeview);
 172
 173                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 174                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 175                         LST_DEFTAG_TOGGLE, FALSE,
 176                         LST_DEFTAG_DATAS, item,
 177                         -1);
 178
 179                 gtk_tree_selection_select_iter (gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), &iter);
 180
 181         }
 182 }
 183
 184 guint32
 185 ui_tag_listview_get_selected_key(GtkTreeView *treeview)
 186 {
 187 GtkTreeSelection *selection;
 188 GtkTreeModel             *model;
 189 GtkTreeIter                      iter;
 190
 191         selection = gtk_tree_view_get_selection(treeview);
 192         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 193         {
 194         Tag *item;
 195
 196                 gtk_tree_model_get(model, &iter, LST_DEFTAG_DATAS, &item, -1);
 197
 198                 if( item!= NULL  )
 199                         return item->key;
 200         }
 201         return 0;
 202 }
 203
 204 void
 205 ui_tag_listview_remove_selected(GtkTreeView *treeview)
 206 {
 207 GtkTreeSelection *selection;
 208 GtkTreeModel             *model;
 209 GtkTreeIter                      iter;
 210
 211         selection = gtk_tree_view_get_selection(treeview);
 212         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 213         {
 214                 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 215         }
 216 }
 217
 218
 219 void ui_tag_listview_populate(GtkWidget *view, gint insert_type)
 220 {
 221 GtkTreeModel *model;
 222 GtkTreeIter     iter;
 223 GList *ltag, *list;
 224
 225         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 226
 227         gtk_list_store_clear (GTK_LIST_STORE(model));
 228
 229         g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
 230         gtk_tree_view_set_model(GTK_TREE_VIEW(view), NULL); /* Detach model from view */
 231
 232         /* populate */
 233         //g_hash_table_foreach(GLOBALS->h_tag, (GHFunc)ui_tag_listview_populate_ghfunc, model);
 234         ltag = list = g_hash_table_get_values(GLOBALS->h_tag);
 235         while (list != NULL)
 236         {
 237         Tag *item = list->data;
 238
 239                 DB( g_print(" populate: %d\n", item->key) );
 240
 241                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 242                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 243                         LST_DEFTAG_TOGGLE       , FALSE,
 244                         LST_DEFTAG_DATAS, item,
 245                         -1);
 246
 247                 list = g_list_next(list);
 248         }
 249         g_list_free(ltag);
 250
 251         gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); /* Re-attach model to view */
 252         g_object_unref(model);
 253 }
 254
 255
 256 GtkWidget *
 257 ui_tag_listview_new(gboolean withtoggle)
 258 {
 259 GtkListStore *store;
 260 GtkWidget *treeview;
 261 GtkCellRenderer         *renderer;
 262 GtkTreeViewColumn       *column;
 263
 264         // create list store
 265         store = gtk_list_store_new(NUM_LST_DEFTAG,
 266                 G_TYPE_BOOLEAN,
 267                 G_TYPE_POINTER
 268                 );
 269
 270         // treeview
 271         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 272         g_object_unref(store);
 273
 274         gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (treeview), PREFS->grid_lines);
 275
 276         // column 1: toggle
 277         if( withtoggle == TRUE )
 278         {
 279                 renderer = gtk_cell_renderer_toggle_new ();
 280                 column = gtk_tree_view_column_new_with_attributes (_("Visible"),
 281                                                              renderer,
 282                                                              "active", LST_DEFTAG_TOGGLE,
 283                                                              NULL);
 284                 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 285
 286                 g_signal_connect (renderer, "toggled",
 287                             G_CALLBACK (ui_tag_listview_toggled_cb), store);
 288
 289         }
 290
 291         // column 2: name
 292         column = gtk_tree_view_column_new();
 293
 294         renderer = gtk_cell_renderer_text_new ();
 295         g_object_set(renderer,
 296                 "ellipsize", PANGO_ELLIPSIZE_END,
 297             "ellipsize-set", TRUE,
 298             NULL);
 299
 300         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 301         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_tag_listview_name_cell_data_function, GINT_TO_POINTER(LST_DEFTAG_DATAS), NULL);
 302
 303         gtk_tree_view_column_set_resizable(column, TRUE);
 304         gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 305
 306         // treeviewattribute
 307         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview), FALSE);
 308         gtk_tree_view_set_reorderable (GTK_TREE_VIEW(treeview), TRUE);
 309
 310         gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), ui_tag_listview_compare_func, NULL, NULL);
 311         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 312
 313         return treeview;
 314 }
 315
 316
 317
 318 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 319
 320
 321 /**
 322  * ui_tag_manage_dialog_add:
 323  *
 324  */
 325 static void
 326 ui_tag_manage_dialog_add(GtkWidget *widget, gpointer user_data)
 327 {
 328 struct ui_tag_manage_dialog_data *data;
 329 Tag *item;
 330 gchar *name;
 331
 332         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 333         DB( g_print("(defayee) add (data=%p)\n", data) );
 334
 335         name = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_name));
 336
 337         item = da_tag_malloc ();
 338         item->name = g_strdup(name);
 339
 340         g_strstrip(item->name);
 341
 342         if( strlen(item->name) > 0 )
 343         {
 344                 if( da_tag_append(item) )
 345                 {
 346                         ui_tag_listview_add(GTK_TREE_VIEW(data->LV_tag), item);
 347                         data->change++;
 348                 }
 349         }
 350         else
 351                 da_tag_free (item);
 352
 353         gtk_entry_set_text(GTK_ENTRY(data->ST_name), "");
 354 }
 355
 356
 357 static void ui_tag_manage_dialog_edit_entry_cb(GtkEditable *editable, gpointer user_data)
 358 {
 359 GtkDialog *window = user_data;
 360 const gchar *buffer;
 361
 362         buffer = gtk_entry_get_text(GTK_ENTRY(editable));
 363         gtk_dialog_set_response_sensitive(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT, strlen(buffer) > 0 ? TRUE : FALSE);
 364 }
 365
 366
 367 static void ui_tag_manage_dialog_edit(GtkWidget *dowidget, gpointer user_data)
 368 {
 369 struct ui_tag_manage_dialog_data *data;
 370 GtkWidget *dialog, *content_area, *content_grid, *group_grid;
 371 GtkWidget *label, *widget;
 372 GtkWidget *ST_name;
 373 gint crow, row;
 374 guint32 key;
 375
 376         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(dowidget, GTK_TYPE_WINDOW)), "inst_data");
 377         DB( g_print("(defayee) modify %p\n", data) );
 378
 379         key = ui_tag_listview_get_selected_key(GTK_TREE_VIEW(data->LV_tag));
 380         if( key > 0 )
 381         {
 382         Tag *item;
 383
 384                 item = da_tag_get( key );
 385
 386                 dialog = gtk_dialog_new_with_buttons (_("Edit..."),
 387                                                     GTK_WINDOW (data->window),
 388                                                     0,
 389                                                     _("_Cancel"),
 390                                                     GTK_RESPONSE_REJECT,
 391                                                     _("_OK"),
 392                                                     GTK_RESPONSE_ACCEPT,
 393                                                     NULL);
 394
 395                 content_area = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
 396
 397                 content_grid = gtk_grid_new();
 398                 gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
 399                 gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
 400                 gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
 401                 gtk_box_pack_start (GTK_BOX (content_area), content_grid, TRUE, TRUE, 0);
 402
 403                 crow = 0;
 404                 // group :: General
 405                 group_grid = gtk_grid_new ();
 406                 gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 407                 gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 408                 gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow++, 1, 1);
 409
 410                 //label = make_label_group(_("General"));
 411                 //gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
 412
 413                 row = 1;
 414                 label = make_label_widget(_("_Name:"));
 415                 gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 416                 widget = gtk_entry_new();
 417                 ST_name = widget;
 418                 gtk_widget_set_hexpand(widget, TRUE);
 419                 gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 420
 421                 g_signal_connect (G_OBJECT (ST_name), "changed", G_CALLBACK (ui_tag_manage_dialog_edit_entry_cb), dialog);
 422
 423                 gtk_widget_show_all(content_grid);
 424
 425
 426                 gtk_dialog_set_default_response(GTK_DIALOG( dialog ), GTK_RESPONSE_ACCEPT);
 427
 428                 //wait for the user
 429                 gint result = gtk_dialog_run (GTK_DIALOG (dialog));
 430
 431                 if(result == GTK_RESPONSE_ACCEPT)
 432                 {
 433                 const gchar *name;
 434
 435                         // 1: manage renaming
 436                         name = gtk_entry_get_text(GTK_ENTRY(ST_name));
 437                         // ignore if item is empty
 438                         if (name && *name)
 439                         {
 440                                 if( tag_rename(item, name) )
 441                                 {
 442                                         //to redraw the active entry
 443                                         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_tag));
 444                                         data->change++;
 445                                 }
 446                                 else
 447                                 {
 448                                         ui_dialog_msg_infoerror(GTK_WINDOW(dialog), GTK_MESSAGE_ERROR,
 449                                                 _("Error"),
 450                                                 _("Cannot rename this Tag,\n"
 451                                                 "from '%s' to '%s',\n"
 452                                                 "this name already exists."),
 453                                                 item->name,
 454                                                 name
 455                                                 );
 456
 457                                 }
 458                         }
 459
 460
 461             }
 462
 463                 // cleanup and destroy
 464                 gtk_widget_destroy (dialog);
 465         }
 466
 467 }
 468
 469
 470 /*
 471 ** delete the selected payee to our treeview and temp GList
 472 */
 473 static void ui_tag_manage_dialog_delete(GtkWidget *widget, gpointer user_data)
 474 {
 475 struct ui_tag_manage_dialog_data *data;
 476 Tag *item;
 477 guint32 key;
 478 gint result;
 479
 480
 481         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 482         DB( g_print("(ui_tag_manage_dialog) delete (data=%p)\n", data) );
 483
 484         key = ui_tag_listview_get_selected_key(GTK_TREE_VIEW(data->LV_tag));
 485         if( key > 0 )
 486         {
 487         gchar *title;
 488         gchar *secondtext = NULL;
 489
 490                 item = da_tag_get(key);
 491
 492                 title = g_strdup_printf (
 493                         _("Are you sure you want to permanently delete '%s'?"), item->name);
 494
 495                 if( item->usage_count > 0 )
 496                 {
 497                         secondtext = _("This payee is used.\n"
 498                             "Any transaction using that payee will be set to (no payee)");
 499                 }
 500
 501                 result = ui_dialog_msg_confirm_alert(
 502                                 GTK_WINDOW(data->window),
 503                                 title,
 504                                 secondtext,
 505                                 _("_Delete")
 506                         );
 507
 508                 g_free(title);
 509
 510                 if( result == GTK_RESPONSE_OK )
 511                 {
 512                         payee_move(key, 0);
 513                         ui_tag_listview_remove_selected(GTK_TREE_VIEW(data->LV_tag));
 514                         da_tag_remove(key);
 515                         data->change++;
 516                 }
 517
 518         }
 519 }
 520
 521
 522 static void ui_tag_manage_dialog_update(GtkWidget *treeview, gpointer user_data)
 523 {
 524 struct ui_tag_manage_dialog_data *data;
 525 gboolean sensitive;
 526 guint32 key;
 527
 528         DB( g_print("\n(ui_tag_manage_dialog) cursor changed\n") );
 529
 530         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW)), "inst_data");
 531
 532         key = ui_tag_listview_get_selected_key(GTK_TREE_VIEW(data->LV_tag));
 533
 534         sensitive = (key > 0) ? TRUE : FALSE;
 535         gtk_widget_set_sensitive(data->BT_edit, sensitive);
 536         gtk_widget_set_sensitive(data->BT_delete, sensitive);
 537
 538 }
 539
 540
 541 /*
 542 **
 543 */
 544 static void ui_tag_manage_dialog_selection(GtkTreeSelection *treeselection, gpointer user_data)
 545 {
 546         ui_tag_manage_dialog_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
 547 }
 548
 549 static void ui_tag_manage_dialog_onRowActivated (GtkTreeView        *treeview,
 550                        GtkTreePath        *path,
 551                        GtkTreeViewColumn  *col,
 552                        gpointer            user_data)
 553 {
 554 GtkTreeModel             *model;
 555 GtkTreeIter                      iter;
 556
 557         DB( g_print("ui_tag_manage_dialog_onRowActivated()\n") );
 558
 559
 560         model = gtk_tree_view_get_model(treeview);
 561         gtk_tree_model_get_iter_first(model, &iter);
 562         if(gtk_tree_selection_iter_is_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), &iter) == FALSE)
 563         {
 564                 ui_tag_manage_dialog_edit(GTK_WIDGET(treeview), NULL);
 565         }
 566 }
 567
 568
 569 GtkWidget *ui_tag_manage_dialog (void)
 570 {
 571 struct ui_tag_manage_dialog_data data;
 572 GtkWidget *dialog, *content, *mainvbox, *box, *bbox, *treeview, *scrollwin, *table, *addreveal;
 573 gint w, h, row;
 574
 575         dialog = gtk_dialog_new_with_buttons (_("Manage Tags"),
 576                                             GTK_WINDOW(GLOBALS->mainwindow),
 577                                                 0,
 578                                             _("_Close"), GTK_RESPONSE_ACCEPT,
 579                                             NULL);
 580
 581         /*dialog = g_object_new (GTK_TYPE_DIALOG, "use-header-bar", TRUE, NULL);
 582         gtk_window_set_title (GTK_WINDOW (dialog), _("Manage Tags"));
 583         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW(GLOBALS->mainwindow));
 584         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 585         */
 586         //gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
 587
 588         data.window = dialog;
 589         data.change = 0;
 590
 591         //gtk_window_set_icon_name(GTK_WINDOW (dialog), ICONNAME_HB_TAG);
 592
 593         //set a nice dialog size
 594         gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
 595         gtk_window_set_default_size (GTK_WINDOW(dialog), -1, h/PHI);
 596
 597
 598         //store our dialog private data
 599         g_object_set_data(G_OBJECT(dialog), "inst_data", (gpointer)&data);
 600         DB( g_print("(ui_tag_manage_dialog) dialog=%p, inst_data=%p\n", dialog, &data) );
 601
 602     g_signal_connect (dialog, "destroy",
 603                         G_CALLBACK (gtk_widget_destroyed), &dialog);
 604
 605         //dialog contents
 606         content = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
 607         mainvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
 608         gtk_box_pack_start (GTK_BOX (content), mainvbox, TRUE, TRUE, 0);
 609         gtk_container_set_border_width (GTK_CONTAINER(mainvbox), SPACING_MEDIUM);
 610
 611     //our table
 612         table = gtk_grid_new ();
 613         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_SMALL);
 614         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
 615         gtk_box_pack_start (GTK_BOX (mainvbox), table, TRUE, TRUE, 0);
 616
 617         row = 0;
 618         bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_MEDIUM);
 619         gtk_grid_attach (GTK_GRID (table), bbox, 0, row, 2, 1);
 620         //test headerbar
 621         //content = gtk_dialog_get_header_bar(GTK_DIALOG (dialog));
 622
 623         row++;
 624         box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 625         gtk_grid_attach (GTK_GRID (table), box, 0, row, 2, 1);
 626
 627         scrollwin = gtk_scrolled_window_new(NULL,NULL);
 628         gtk_container_add(GTK_CONTAINER(box), scrollwin);
 629         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
 630         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 631         gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrollwin), HB_MINHEIGHT_LIST);
 632         gtk_widget_set_hexpand (scrollwin, TRUE);
 633         gtk_widget_set_vexpand (scrollwin, TRUE);
 634         treeview = ui_tag_listview_new(FALSE);
 635         data.LV_tag = treeview;
 636         gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
 637
 638         row++;
 639         addreveal = gtk_revealer_new ();
 640         gtk_grid_attach (GTK_GRID (table), addreveal, 0, row, 2, 1);
 641         data.ST_name = gtk_entry_new ();
 642         gtk_entry_set_placeholder_text(GTK_ENTRY(data.ST_name), _("new tag") );
 643         gtk_widget_set_hexpand (data.ST_name, TRUE);
 644         gtk_container_add(GTK_CONTAINER(addreveal), data.ST_name);
 645
 646         row++;
 647         bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
 648         gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
 649         gtk_box_set_spacing (GTK_BOX (bbox), SPACING_SMALL);
 650         gtk_grid_attach (GTK_GRID (table), bbox, 0, row, 2, 1);
 651
 652         data.BT_add = gtk_toggle_button_new_with_mnemonic(_("_Add"));
 653         gtk_container_add (GTK_CONTAINER (bbox), data.BT_add);
 654
 655         //todo: useless ?
 656         data.BT_edit = gtk_button_new_with_mnemonic(_("_Edit"));
 657         gtk_container_add (GTK_CONTAINER (bbox), data.BT_edit);
 658
 659         data.BT_delete = gtk_button_new_with_mnemonic(_("_Delete"));
 660         gtk_container_add (GTK_CONTAINER (bbox), data.BT_delete);
 661
 662
 663         //connect all our signals
 664         g_object_bind_property (data.BT_add, "active", addreveal, "reveal-child", G_BINDING_BIDIRECTIONAL);
 665
 666         g_signal_connect (G_OBJECT (data.ST_name), "activate", G_CALLBACK (ui_tag_manage_dialog_add), NULL);
 667
 668         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data.LV_tag)), "changed", G_CALLBACK (ui_tag_manage_dialog_selection), NULL);
 669         g_signal_connect (GTK_TREE_VIEW(data.LV_tag), "row-activated", G_CALLBACK (ui_tag_manage_dialog_onRowActivated), NULL);
 670
 671         g_signal_connect (G_OBJECT (data.BT_edit), "clicked", G_CALLBACK (ui_tag_manage_dialog_edit), NULL);
 672         g_signal_connect (G_OBJECT (data.BT_delete), "clicked", G_CALLBACK (ui_tag_manage_dialog_delete), NULL);
 673
 674         //setup, init and show dialog
 675         //tag_fill_usage();
 676         ui_tag_listview_populate(data.LV_tag, 0);
 677         ui_tag_manage_dialog_update(data.LV_tag, NULL);
 678
 679         gtk_widget_show_all (dialog);
 680
 681         //wait for the user
 682         gint result = gtk_dialog_run (GTK_DIALOG (dialog));
 683
 684         switch (result)
 685     {
 686         case GTK_RESPONSE_ACCEPT:
 687            //do_application_specific_something ();
 688            break;
 689         default:
 690            //do_nothing_since_dialog_was_cancelled ();
 691            break;
 692     }
 693
 694         // cleanup and destroy
 695
 696         gtk_widget_destroy (dialog);
 697
 698         GLOBALS->changes_count += data.change;
 699
 700         return NULL;
 701 }
 702