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 //TODO: still used in rep_time
  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 ui_tag_popover_cb_row_activated(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
  83 {
  84 GtkTreeSelection *treeselection;
  85 GtkTreeModel *model;
  86 GtkTreeIter iter;
  87 GtkEntry *entry = user_data;
  88
  89         if( GTK_IS_ENTRY(entry) )
  90         {
  91                 treeselection = gtk_tree_view_get_selection(tree_view);
  92                 if( gtk_tree_selection_get_selected(treeselection, &model, &iter) )
  93                 {
  94                 Tag *item;
  95
  96                         gtk_tree_model_get(model, &iter, LST_DEFTAG_DATAS, &item, -1);
  97
  98                         hbtk_entry_tag_name_append(GTK_ENTRY(user_data), item->name);
  99                 }
 100         }
 101 }
 102
 103
 104 GtkWidget *
 105 ui_tag_popover_list(GtkWidget *entry)
 106 {
 107 GtkWidget *box, *menubutton, *image, *scrollwin, *treeview;
 108
 109         menubutton = gtk_menu_button_new ();
 110         image = gtk_image_new_from_icon_name ("pan-down-symbolic", GTK_ICON_SIZE_BUTTON);
 111         gtk_container_add(GTK_CONTAINER(menubutton), image);
 112
 113         //gtk_menu_button_set_direction (GTK_MENU_BUTTON(menubutton), GTK_ARROW_DOWN );
 114         //gtk_widget_set_halign (menubutton, GTK_ALIGN_END);
 115         gtk_widget_show_all(menubutton);
 116
 117         //GtkWidget *template = ui_popover_tpl_create(data);
 118
 119         box = gtk_box_new(GTK_ORIENTATION_VERTICAL, SPACING_MEDIUM);
 120         scrollwin = gtk_scrolled_window_new(NULL,NULL);
 121         gtk_box_pack_start(GTK_BOX(box), scrollwin, TRUE, TRUE, 0);
 122         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
 123         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 124         treeview = ui_tag_listview_new(FALSE);
 125         //data.LV_tag = treeview;
 126         gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
 127         gtk_widget_show_all(box);
 128
 129         gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(treeview), TRUE);
 130         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
 131         gtk_tree_view_set_activate_on_single_click(GTK_TREE_VIEW(treeview), TRUE);
 132
 133
 134         GtkWidget *popover = create_popover (menubutton, box, GTK_POS_BOTTOM);
 135         gtk_widget_set_size_request (popover, HB_MINWIDTH_LIST, HB_MINHEIGHT_LIST);
 136
 137         gtk_menu_button_set_popover(GTK_MENU_BUTTON(menubutton), popover);
 138
 139         ui_tag_listview_populate(treeview, 0);
 140
 141         g_signal_connect (treeview, "row-activated", G_CALLBACK (ui_tag_popover_cb_row_activated), entry);
 142         g_signal_connect_swapped(treeview, "row-activated", G_CALLBACK(gtk_popover_popdown), popover);
 143
 144         return menubutton;
 145 }
 146
 147
 148 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 149
 150
 151 static void
 152 ui_tag_listview_toggled_cb (GtkCellRendererToggle *cell,
 153                gchar                 *path_str,
 154                gpointer               data)
 155 {
 156   GtkTreeModel *model = (GtkTreeModel *)data;
 157   GtkTreeIter  iter;
 158   GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
 159   gboolean fixed;
 160
 161   /* get toggled iter */
 162   gtk_tree_model_get_iter (model, &iter, path);
 163   gtk_tree_model_get (model, &iter, LST_DEFTAG_TOGGLE, &fixed, -1);
 164
 165   /* do something with the value */
 166   fixed ^= 1;
 167
 168   /* set new value */
 169   gtk_list_store_set (GTK_LIST_STORE (model), &iter, LST_DEFTAG_TOGGLE, fixed, -1);
 170
 171   /* clean up */
 172   gtk_tree_path_free (path);
 173 }
 174
 175 static gint
 176 ui_tag_listview_compare_func (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer userdata)
 177 {
 178 gint retval = 0;
 179 Tag *entry1, *entry2;
 180 //gchar *name1, *name2;
 181
 182     gtk_tree_model_get(model, a, LST_DEFTAG_DATAS, &entry1, -1);
 183     gtk_tree_model_get(model, b, LST_DEFTAG_DATAS, &entry2, -1);
 184
 185         retval = hb_string_utf8_compare(entry1->name, entry2->name);
 186
 187     return retval;
 188 }
 189
 190
 191 static void
 192 ui_tag_listview_name_cell_data_function (GtkTreeViewColumn *col,
 193                                 GtkCellRenderer *renderer,
 194                                 GtkTreeModel *model,
 195                                 GtkTreeIter *iter,
 196                                 gpointer user_data)
 197 {
 198 Tag *entry;
 199 gchar *name;
 200 #if MYDEBUG
 201 gchar *string;
 202 #endif
 203
 204         gtk_tree_model_get(model, iter, LST_DEFTAG_DATAS, &entry, -1);
 205         if(entry->name == NULL)
 206                 name = _("(none)");             // can never occurs !
 207         else
 208                 name = entry->name;
 209
 210         #if MYDEBUG
 211                 string = g_strdup_printf ("[%d] %s", entry->key, name );
 212                 g_object_set(renderer, "text", string, NULL);
 213                 g_free(string);
 214         #else
 215                 g_object_set(renderer, "text", name, NULL);
 216         #endif
 217
 218 }
 219
 220
 221
 222 /* = = = = = = = = = = = = = = = = */
 223
 224 /**
 225  * tag_list_add:
 226  *
 227  * Add a single element (useful for dynamics add)
 228  *
 229  * Return value: --
 230  *
 231  */
 232 void
 233 ui_tag_listview_add(GtkTreeView *treeview, Tag *item)
 234 {
 235         if( item->name != NULL )
 236         {
 237         GtkTreeModel *model;
 238         GtkTreeIter     iter;
 239
 240                 model = gtk_tree_view_get_model(treeview);
 241
 242                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 243                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 244                         LST_DEFTAG_TOGGLE, FALSE,
 245                         LST_DEFTAG_DATAS, item,
 246                         -1);
 247
 248                 gtk_tree_selection_select_iter (gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), &iter);
 249
 250         }
 251 }
 252
 253 guint32
 254 ui_tag_listview_get_selected_key(GtkTreeView *treeview)
 255 {
 256 GtkTreeSelection *selection;
 257 GtkTreeModel             *model;
 258 GtkTreeIter                      iter;
 259
 260         selection = gtk_tree_view_get_selection(treeview);
 261         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 262         {
 263         Tag *item;
 264
 265                 gtk_tree_model_get(model, &iter, LST_DEFTAG_DATAS, &item, -1);
 266
 267                 if( item!= NULL  )
 268                         return item->key;
 269         }
 270         return 0;
 271 }
 272
 273 void
 274 ui_tag_listview_remove_selected(GtkTreeView *treeview)
 275 {
 276 GtkTreeSelection *selection;
 277 GtkTreeModel             *model;
 278 GtkTreeIter                      iter;
 279
 280         selection = gtk_tree_view_get_selection(treeview);
 281         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 282         {
 283                 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 284         }
 285 }
 286
 287
 288 void ui_tag_listview_populate(GtkWidget *view, gint insert_type)
 289 {
 290 GtkTreeModel *model;
 291 GtkTreeIter     iter;
 292 GList *ltag, *list;
 293
 294         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 295
 296         gtk_list_store_clear (GTK_LIST_STORE(model));
 297
 298         g_object_ref(model); /* Make sure the model stays with us after the tree view unrefs it */
 299         gtk_tree_view_set_model(GTK_TREE_VIEW(view), NULL); /* Detach model from view */
 300
 301         /* populate */
 302         //g_hash_table_foreach(GLOBALS->h_tag, (GHFunc)ui_tag_listview_populate_ghfunc, model);
 303         ltag = list = g_hash_table_get_values(GLOBALS->h_tag);
 304         while (list != NULL)
 305         {
 306         Tag *item = list->data;
 307
 308                 DB( g_print(" populate: %d\n", item->key) );
 309
 310                 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
 311                 gtk_list_store_set (GTK_LIST_STORE(model), &iter,
 312                         LST_DEFTAG_TOGGLE       , FALSE,
 313                         LST_DEFTAG_DATAS, item,
 314                         -1);
 315
 316                 list = g_list_next(list);
 317         }
 318         g_list_free(ltag);
 319
 320         gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); /* Re-attach model to view */
 321         g_object_unref(model);
 322 }
 323
 324
 325 GtkWidget *
 326 ui_tag_listview_new(gboolean withtoggle)
 327 {
 328 GtkListStore *store;
 329 GtkWidget *treeview;
 330 GtkCellRenderer         *renderer;
 331 GtkTreeViewColumn       *column;
 332
 333         // create list store
 334         store = gtk_list_store_new(NUM_LST_DEFTAG,
 335                 G_TYPE_BOOLEAN,
 336                 G_TYPE_POINTER
 337                 );
 338
 339         // treeview
 340         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 341         g_object_unref(store);
 342
 343         gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (treeview), PREFS->grid_lines);
 344
 345         // column 1: toggle
 346         if( withtoggle == TRUE )
 347         {
 348                 renderer = gtk_cell_renderer_toggle_new ();
 349                 column = gtk_tree_view_column_new_with_attributes (_("Visible"),
 350                                                              renderer,
 351                                                              "active", LST_DEFTAG_TOGGLE,
 352                                                              NULL);
 353                 gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 354
 355                 g_signal_connect (renderer, "toggled",
 356                             G_CALLBACK (ui_tag_listview_toggled_cb), store);
 357
 358         }
 359
 360         // column 2: name
 361         column = gtk_tree_view_column_new();
 362
 363         renderer = gtk_cell_renderer_text_new ();
 364         g_object_set(renderer,
 365                 "ellipsize", PANGO_ELLIPSIZE_END,
 366             "ellipsize-set", TRUE,
 367             NULL);
 368
 369         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 370         gtk_tree_view_column_set_cell_data_func(column, renderer, ui_tag_listview_name_cell_data_function, GINT_TO_POINTER(LST_DEFTAG_DATAS), NULL);
 371
 372         gtk_tree_view_column_set_resizable(column, TRUE);
 373         gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
 374
 375         // treeviewattribute
 376         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview), FALSE);
 377         gtk_tree_view_set_reorderable (GTK_TREE_VIEW(treeview), TRUE);
 378
 379         gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), ui_tag_listview_compare_func, NULL, NULL);
 380         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 381
 382         return treeview;
 383 }
 384
 385
 386
 387 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 388
 389
 390 static void ui_tag_manage_filter_text_handler (GtkEntry    *entry,
 391                           const gchar *text,
 392                           gint         length,
 393                           gint        *position,
 394                           gpointer     data)
 395 {
 396 GtkEditable *editable = GTK_EDITABLE(entry);
 397 gint i, count=0;
 398 gchar *result = g_new0 (gchar, length+1);
 399
 400   for (i=0; i < length; i++)
 401   {
 402     if (text[i]==' ')
 403       continue;
 404     result[count++] = text[i];
 405   }
 406
 407
 408   if (count > 0) {
 409     g_signal_handlers_block_by_func (G_OBJECT (editable),
 410                                      G_CALLBACK (ui_tag_manage_filter_text_handler),
 411                                      data);
 412     gtk_editable_insert_text (editable, result, count, position);
 413     g_signal_handlers_unblock_by_func (G_OBJECT (editable),
 414                                        G_CALLBACK (ui_tag_manage_filter_text_handler),
 415                                        data);
 416   }
 417   g_signal_stop_emission_by_name (G_OBJECT (editable), "insert_text");
 418
 419   g_free (result);
 420 }
 421
 422
 423
 424 /**
 425  * ui_tag_manage_dialog_add:
 426  *
 427  */
 428 static void
 429 ui_tag_manage_dialog_add(GtkWidget *widget, gpointer user_data)
 430 {
 431 struct ui_tag_manage_dialog_data *data;
 432 Tag *item;
 433 gchar *name;
 434
 435         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 436         DB( g_print("(defayee) add (data=%p)\n", data) );
 437
 438         name = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_name));
 439
 440         item = da_tag_malloc ();
 441         item->name = g_strdup(name);
 442
 443         g_strstrip(item->name);
 444
 445         if( strlen(item->name) > 0 )
 446         {
 447                 if( da_tag_append(item) )
 448                 {
 449                         ui_tag_listview_add(GTK_TREE_VIEW(data->LV_tag), item);
 450                         data->change++;
 451                 }
 452         }
 453         else
 454                 da_tag_free (item);
 455
 456         gtk_entry_set_text(GTK_ENTRY(data->ST_name), "");
 457 }
 458
 459
 460 static void ui_tag_manage_dialog_edit_entry_cb(GtkEditable *editable, gpointer user_data)
 461 {
 462 GtkDialog *window = user_data;
 463 const gchar *buffer;
 464
 465         buffer = gtk_entry_get_text(GTK_ENTRY(editable));
 466         gtk_dialog_set_response_sensitive(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT, strlen(buffer) > 0 ? TRUE : FALSE);
 467 }
 468
 469
 470 static void ui_tag_manage_dialog_edit(GtkWidget *dowidget, gpointer user_data)
 471 {
 472 struct ui_tag_manage_dialog_data *data;
 473 GtkWidget *dialog, *content_area, *content_grid, *group_grid;
 474 GtkWidget *label, *widget;
 475 GtkWidget *ST_name;
 476 gint crow, row;
 477 guint32 key;
 478
 479         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(dowidget, GTK_TYPE_WINDOW)), "inst_data");
 480         DB( g_print("(defayee) modify %p\n", data) );
 481
 482         key = ui_tag_listview_get_selected_key(GTK_TREE_VIEW(data->LV_tag));
 483         if( key > 0 )
 484         {
 485         Tag *item;
 486
 487                 item = da_tag_get( key );
 488
 489                 dialog = gtk_dialog_new_with_buttons (_("Edit..."),
 490                                                     GTK_WINDOW (data->window),
 491                                                     0,
 492                                                     _("_Cancel"),
 493                                                     GTK_RESPONSE_REJECT,
 494                                                     _("_OK"),
 495                                                     GTK_RESPONSE_ACCEPT,
 496                                                     NULL);
 497
 498                 content_area = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
 499
 500                 content_grid = gtk_grid_new();
 501                 gtk_grid_set_row_spacing (GTK_GRID (content_grid), SPACING_LARGE);
 502                 gtk_orientable_set_orientation(GTK_ORIENTABLE(content_grid), GTK_ORIENTATION_VERTICAL);
 503                 gtk_container_set_border_width (GTK_CONTAINER(content_grid), SPACING_MEDIUM);
 504                 gtk_box_pack_start (GTK_BOX (content_area), content_grid, TRUE, TRUE, 0);
 505
 506                 crow = 0;
 507                 // group :: General
 508                 group_grid = gtk_grid_new ();
 509                 gtk_grid_set_row_spacing (GTK_GRID (group_grid), SPACING_SMALL);
 510                 gtk_grid_set_column_spacing (GTK_GRID (group_grid), SPACING_MEDIUM);
 511                 gtk_grid_attach (GTK_GRID (content_grid), group_grid, 0, crow++, 1, 1);
 512
 513                 //label = make_label_group(_("General"));
 514                 //gtk_grid_attach (GTK_GRID (group_grid), label, 0, 0, 3, 1);
 515
 516                 row = 1;
 517                 label = make_label_widget(_("_Name:"));
 518                 gtk_grid_attach (GTK_GRID (group_grid), label, 1, row, 1, 1);
 519                 widget = gtk_entry_new();
 520                 ST_name = widget;
 521                 gtk_widget_set_hexpand(widget, TRUE);
 522                 gtk_grid_attach (GTK_GRID (group_grid), widget, 2, row, 1, 1);
 523
 524                 g_signal_connect (G_OBJECT (ST_name), "changed", G_CALLBACK (ui_tag_manage_dialog_edit_entry_cb), dialog);
 525
 526                 gtk_widget_show_all(content_grid);
 527
 528
 529                 gtk_dialog_set_default_response(GTK_DIALOG( dialog ), GTK_RESPONSE_ACCEPT);
 530
 531                 //wait for the user
 532                 gint result = gtk_dialog_run (GTK_DIALOG (dialog));
 533
 534                 if(result == GTK_RESPONSE_ACCEPT)
 535                 {
 536                 const gchar *name;
 537
 538                         // 1: manage renaming
 539                         name = gtk_entry_get_text(GTK_ENTRY(ST_name));
 540                         // ignore if item is empty
 541                         if (name && *name)
 542                         {
 543                                 if( tag_rename(item, name) )
 544                                 {
 545                                         //to redraw the active entry
 546                                         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_tag));
 547                                         data->change++;
 548                                 }
 549                                 else
 550                                 {
 551                                         ui_dialog_msg_infoerror(GTK_WINDOW(dialog), GTK_MESSAGE_ERROR,
 552                                                 _("Error"),
 553                                                 _("Cannot rename this Tag,\n"
 554                                                 "from '%s' to '%s',\n"
 555                                                 "this name already exists."),
 556                                                 item->name,
 557                                                 name
 558                                                 );
 559
 560                                 }
 561                         }
 562
 563
 564             }
 565
 566                 // cleanup and destroy
 567                 gtk_widget_destroy (dialog);
 568         }
 569
 570 }
 571
 572
 573 /*
 574 ** delete the selected payee to our treeview and temp GList
 575 */
 576 static void ui_tag_manage_dialog_delete(GtkWidget *widget, gpointer user_data)
 577 {
 578 struct ui_tag_manage_dialog_data *data;
 579 Tag *item;
 580 guint32 key;
 581 gint result;
 582
 583
 584         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
 585         DB( g_print("(ui_tag_manage_dialog) delete (data=%p)\n", data) );
 586
 587         key = ui_tag_listview_get_selected_key(GTK_TREE_VIEW(data->LV_tag));
 588         if( key > 0 )
 589         {
 590         gchar *title;
 591         gchar *secondtext = NULL;
 592
 593                 item = da_tag_get(key);
 594
 595                 title = g_strdup_printf (
 596                         _("Are you sure you want to permanently delete '%s'?"), item->name);
 597
 598                 if( item->usage_count > 0 )
 599                 {
 600                         secondtext = _("This payee is used.\n"
 601                             "Any transaction using that payee will be set to (no payee)");
 602                 }
 603
 604                 result = ui_dialog_msg_confirm_alert(
 605                                 GTK_WINDOW(data->window),
 606                                 title,
 607                                 secondtext,
 608                                 _("_Delete")
 609                         );
 610
 611                 g_free(title);
 612
 613                 if( result == GTK_RESPONSE_OK )
 614                 {
 615                         payee_move(key, 0);
 616                         ui_tag_listview_remove_selected(GTK_TREE_VIEW(data->LV_tag));
 617                         da_tag_remove(key);
 618                         data->change++;
 619                 }
 620
 621         }
 622 }
 623
 624
 625 static void ui_tag_manage_dialog_update(GtkWidget *treeview, gpointer user_data)
 626 {
 627 struct ui_tag_manage_dialog_data *data;
 628 gboolean sensitive;
 629 guint32 key;
 630
 631         DB( g_print("\n(ui_tag_manage_dialog) cursor changed\n") );
 632
 633         data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(GTK_WIDGET(treeview), GTK_TYPE_WINDOW)), "inst_data");
 634
 635         key = ui_tag_listview_get_selected_key(GTK_TREE_VIEW(data->LV_tag));
 636
 637         sensitive = (key > 0) ? TRUE : FALSE;
 638         gtk_widget_set_sensitive(data->BT_edit, sensitive);
 639         gtk_widget_set_sensitive(data->BT_delete, sensitive);
 640
 641 }
 642
 643
 644 /*
 645 **
 646 */
 647 static void ui_tag_manage_dialog_selection(GtkTreeSelection *treeselection, gpointer user_data)
 648 {
 649         ui_tag_manage_dialog_update(GTK_WIDGET(gtk_tree_selection_get_tree_view (treeselection)), NULL);
 650 }
 651
 652 static void ui_tag_manage_dialog_onRowActivated (GtkTreeView        *treeview,
 653                        GtkTreePath        *path,
 654                        GtkTreeViewColumn  *col,
 655                        gpointer            user_data)
 656 {
 657 GtkTreeModel             *model;
 658 GtkTreeIter                      iter;
 659
 660         DB( g_print("ui_tag_manage_dialog_onRowActivated()\n") );
 661
 662
 663         model = gtk_tree_view_get_model(treeview);
 664         gtk_tree_model_get_iter_first(model, &iter);
 665         if(gtk_tree_selection_iter_is_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), &iter) == FALSE)
 666         {
 667                 ui_tag_manage_dialog_edit(GTK_WIDGET(treeview), NULL);
 668         }
 669 }
 670
 671
 672 GtkWidget *ui_tag_manage_dialog (void)
 673 {
 674 struct ui_tag_manage_dialog_data data;
 675 GtkWidget *dialog, *content, *mainvbox, *box, *bbox, *treeview, *scrollwin, *table, *addreveal;
 676 gint w, h, row;
 677
 678         dialog = gtk_dialog_new_with_buttons (_("Manage Tags"),
 679                                             GTK_WINDOW(GLOBALS->mainwindow),
 680                                                 0,
 681                                             _("_Close"), GTK_RESPONSE_ACCEPT,
 682                                             NULL);
 683
 684         /*dialog = g_object_new (GTK_TYPE_DIALOG, "use-header-bar", TRUE, NULL);
 685         gtk_window_set_title (GTK_WINDOW (dialog), _("Manage Tags"));
 686         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW(GLOBALS->mainwindow));
 687         gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 688         */
 689         //gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
 690
 691         data.window = dialog;
 692         data.change = 0;
 693
 694         //gtk_window_set_icon_name(GTK_WINDOW (dialog), ICONNAME_HB_TAG);
 695
 696         //set a nice dialog size
 697         gtk_window_get_size(GTK_WINDOW(GLOBALS->mainwindow), &w, &h);
 698         gtk_window_set_default_size (GTK_WINDOW(dialog), -1, h/PHI);
 699
 700
 701         //store our dialog private data
 702         g_object_set_data(G_OBJECT(dialog), "inst_data", (gpointer)&data);
 703         DB( g_print("(ui_tag_manage_dialog) dialog=%p, inst_data=%p\n", dialog, &data) );
 704
 705     g_signal_connect (dialog, "destroy",
 706                         G_CALLBACK (gtk_widget_destroyed), &dialog);
 707
 708         //dialog contents
 709         content = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
 710         mainvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, SPACING_SMALL);
 711         gtk_box_pack_start (GTK_BOX (content), mainvbox, TRUE, TRUE, 0);
 712         gtk_container_set_border_width (GTK_CONTAINER(mainvbox), SPACING_MEDIUM);
 713
 714     //our table
 715         table = gtk_grid_new ();
 716         gtk_grid_set_row_spacing (GTK_GRID (table), SPACING_SMALL);
 717         gtk_grid_set_column_spacing (GTK_GRID (table), SPACING_MEDIUM);
 718         gtk_box_pack_start (GTK_BOX (mainvbox), table, TRUE, TRUE, 0);
 719
 720         row = 0;
 721         bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, SPACING_MEDIUM);
 722         gtk_grid_attach (GTK_GRID (table), bbox, 0, row, 2, 1);
 723         //test headerbar
 724         //content = gtk_dialog_get_header_bar(GTK_DIALOG (dialog));
 725
 726         row++;
 727         box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 728         gtk_grid_attach (GTK_GRID (table), box, 0, row, 2, 1);
 729
 730         scrollwin = gtk_scrolled_window_new(NULL,NULL);
 731         gtk_container_add(GTK_CONTAINER(box), scrollwin);
 732         gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrollwin), GTK_SHADOW_ETCHED_IN);
 733         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 734         gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrollwin), HB_MINHEIGHT_LIST);
 735         gtk_widget_set_hexpand (scrollwin, TRUE);
 736         gtk_widget_set_vexpand (scrollwin, TRUE);
 737         treeview = ui_tag_listview_new(FALSE);
 738         data.LV_tag = treeview;
 739         gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
 740
 741         row++;
 742         addreveal = gtk_revealer_new ();
 743         gtk_grid_attach (GTK_GRID (table), addreveal, 0, row, 2, 1);
 744         data.ST_name = gtk_entry_new ();
 745         gtk_entry_set_placeholder_text(GTK_ENTRY(data.ST_name), _("new tag") );
 746         gtk_widget_set_hexpand (data.ST_name, TRUE);
 747         gtk_container_add(GTK_CONTAINER(addreveal), data.ST_name);
 748
 749         row++;
 750         bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
 751         gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
 752         gtk_box_set_spacing (GTK_BOX (bbox), SPACING_SMALL);
 753         gtk_grid_attach (GTK_GRID (table), bbox, 0, row, 2, 1);
 754
 755         data.BT_add = gtk_toggle_button_new_with_mnemonic(_("_Add"));
 756         gtk_container_add (GTK_CONTAINER (bbox), data.BT_add);
 757
 758         //todo: useless ?
 759         data.BT_edit = gtk_button_new_with_mnemonic(_("_Edit"));
 760         gtk_container_add (GTK_CONTAINER (bbox), data.BT_edit);
 761
 762         data.BT_delete = gtk_button_new_with_mnemonic(_("_Delete"));
 763         gtk_container_add (GTK_CONTAINER (bbox), data.BT_delete);
 764
 765
 766         //connect all our signals
 767         g_object_bind_property (data.BT_add, "active", addreveal, "reveal-child", G_BINDING_BIDIRECTIONAL);
 768
 769         g_signal_connect (G_OBJECT (data.ST_name), "activate", G_CALLBACK (ui_tag_manage_dialog_add), NULL);
 770         g_signal_connect(G_OBJECT(data.ST_name), "insert-text", G_CALLBACK(ui_tag_manage_filter_text_handler), NULL);
 771
 772         g_signal_connect (gtk_tree_view_get_selection(GTK_TREE_VIEW(data.LV_tag)), "changed", G_CALLBACK (ui_tag_manage_dialog_selection), NULL);
 773         g_signal_connect (GTK_TREE_VIEW(data.LV_tag), "row-activated", G_CALLBACK (ui_tag_manage_dialog_onRowActivated), NULL);
 774
 775         g_signal_connect (G_OBJECT (data.BT_edit), "clicked", G_CALLBACK (ui_tag_manage_dialog_edit), NULL);
 776         g_signal_connect (G_OBJECT (data.BT_delete), "clicked", G_CALLBACK (ui_tag_manage_dialog_delete), NULL);
 777
 778         //setup, init and show dialog
 779         //tag_fill_usage();
 780         ui_tag_listview_populate(data.LV_tag, 0);
 781         ui_tag_manage_dialog_update(data.LV_tag, NULL);
 782
 783         gtk_widget_show_all (dialog);
 784
 785         //wait for the user
 786         gint result = gtk_dialog_run (GTK_DIALOG (dialog));
 787
 788         switch (result)
 789     {
 790         case GTK_RESPONSE_ACCEPT:
 791            //do_application_specific_something ();
 792            break;
 793         default:
 794            //do_nothing_since_dialog_was_cancelled ();
 795            break;
 796     }
 797
 798         // cleanup and destroy
 799
 800         gtk_widget_destroy (dialog);
 801
 802         GLOBALS->changes_count += data.change;
 803
 804         return NULL;
 805 }
 806