src/desktop_file.c

   1 /*
   2  * Copyright (C) 2004 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: Vladimir Nadvornik
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "main.h"
  23 #include "desktop_file.h"
  24
  25 #include "editors.h"
  26 #include "filedata.h"
  27 #include "misc.h"
  28 #include "ui_misc.h"
  29 #include "ui_fileops.h"
  30 #include "ui_utildlg.h"
  31 #include "pixbuf_util.h"
  32 #include "window.h"
  33 #include "utilops.h"
  34 #include "layout_util.h"
  35
  36 #define CONFIG_WINDOW_DEF_WIDTH         700
  37 #define CONFIG_WINDOW_DEF_HEIGHT        400
  38
  39
  40
  41 typedef struct _EditorWindow EditorWindow;
  42 struct _EditorWindow
  43 {
  44         GtkWidget *window;
  45         GtkWidget *entry;
  46         GtkWidget *save_button;
  47         GtkTextBuffer *buffer;
  48         gchar *desktop_name;
  49         gboolean modified;
  50 };
  51
  52 typedef struct _EditorListWindow EditorListWindow;
  53 struct _EditorListWindow
  54 {
  55         GtkWidget *window;
  56         GtkWidget *view;
  57         GenericDialog *gd;      /* any open confirm dialogs ? */
  58         GtkWidget *delete_button;
  59         GtkWidget *edit_button;
  60 };
  61
  62 typedef struct _EditorWindowDel_Data EditorWindowDel_Data;
  63 struct _EditorWindowDel_Data
  64 {
  65         EditorListWindow *ewl;
  66         gchar *path;
  67 };
  68
  69 static EditorListWindow *editor_list_window = NULL;
  70
  71 static gboolean editor_window_save(EditorWindow *ew)
  72 {
  73         gchar *dir;
  74         gchar *path;
  75         gchar *text;
  76         GtkTextIter start, end;
  77         GError *error = NULL;
  78         gboolean ret = TRUE;
  79         const gchar *name = gtk_entry_get_text(GTK_ENTRY(ew->entry));
  80
  81         if (!name || !name[0])
  82                 {
  83                 file_util_warning_dialog(_("Can't save"), _("Please specify file name."), GTK_STOCK_DIALOG_ERROR, NULL);
  84                 return FALSE;
  85                 }
  86
  87         gtk_text_buffer_get_bounds(ew->buffer, &start, &end);
  88         text = gtk_text_buffer_get_text(ew->buffer, &start, &end, FALSE);
  89
  90         dir = g_build_filename(get_rc_dir(), "applications", NULL);
  91         path = g_build_filename(dir, name, NULL);
  92
  93         if (!recursive_mkdir_if_not_exists(dir, 0755))
  94                 {
  95                 file_util_warning_dialog(_("Can't save"), _("Could not create directory"), GTK_STOCK_DIALOG_ERROR, NULL);
  96                 ret = FALSE;
  97                 }
  98
  99         if (ret && !g_file_set_contents(path, text, -1, &error))
 100                 {
 101                 file_util_warning_dialog(_("Can't save"), error->message, GTK_STOCK_DIALOG_ERROR, NULL);
 102                 g_error_free(error);
 103                 ret = FALSE;
 104                 }
 105
 106         g_free(path);
 107         g_free(dir);
 108         g_free(text);
 109         layout_editors_reload_start();
 110         /* idle function is not needed, everything should be cached */
 111         layout_editors_reload_finish();
 112         return ret;
 113 }
 114
 115 static void editor_window_close_cb(GtkWidget *widget, gpointer data)
 116 {
 117         EditorWindow *ew = data;
 118
 119         g_free(ew->desktop_name);
 120         gtk_widget_destroy(ew->window);
 121         g_free(ew);
 122 }
 123
 124 static gint editor_window_delete_cb(GtkWidget *w, GdkEventAny *event, gpointer data)
 125 {
 126         editor_window_close_cb(w, data);
 127         return TRUE;
 128 }
 129
 130 static void editor_window_save_cb(GtkWidget *widget, gpointer data)
 131 {
 132         EditorWindow *ew = data;
 133
 134         if (ew->modified)
 135                 {
 136                 editor_window_save(ew);
 137                 }
 138
 139         gtk_widget_set_sensitive(ew->save_button, FALSE);
 140         gtk_text_buffer_set_modified(ew->buffer, FALSE);
 141         ew->modified = FALSE;
 142 }
 143
 144 static void editor_window_text_modified_cb(GtkWidget *widget, gpointer data)
 145 {
 146         EditorWindow *ew = data;
 147
 148         if (gtk_text_buffer_get_modified(ew->buffer))
 149                 {
 150                 gtk_widget_set_sensitive(ew->save_button, TRUE);
 151                 ew->modified = TRUE;
 152                 }
 153 }
 154
 155 static void editor_window_entry_changed_cb(GtkWidget *widget, gpointer data)
 156 {
 157         EditorWindow *ew = data;
 158         const gchar *content = gtk_entry_get_text(GTK_ENTRY(ew->entry));
 159         gboolean modified = ew->modified;
 160
 161         if (!modified)
 162                 {
 163                 modified = (!ew->desktop_name && *content);
 164                 }
 165
 166         if (!modified)
 167                 {
 168                 modified = strcmp(ew->desktop_name, content);
 169                 }
 170
 171         gtk_widget_set_sensitive(ew->save_button, modified);
 172         ew->modified = modified;
 173 }
 174
 175 static void editor_window_new(const gchar *src_path, const gchar *desktop_name)
 176 {
 177         EditorWindow *ew;
 178         GtkWidget *win_vbox;
 179         GtkWidget *hbox;
 180         GtkWidget *button;
 181         GtkWidget *ct_button;
 182         GtkWidget *button_hbox;
 183         GtkWidget *scrolled;
 184         GtkWidget *text_view;
 185         gchar *text;
 186         gsize size;
 187
 188         ew = g_new0(EditorWindow, 1);
 189
 190
 191         ew->window = window_new(GTK_WINDOW_TOPLEVEL, "Desktop", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Desktop file"));
 192         DEBUG_NAME(ew->window);
 193         gtk_window_set_type_hint(GTK_WINDOW(ew->window), GDK_WINDOW_TYPE_HINT_DIALOG);
 194
 195         g_signal_connect(G_OBJECT(ew->window), "delete_event",
 196                          G_CALLBACK(editor_window_delete_cb), ew);
 197
 198         gtk_window_set_default_size(GTK_WINDOW(ew->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
 199         gtk_window_set_resizable(GTK_WINDOW(ew->window), TRUE);
 200         gtk_container_set_border_width(GTK_CONTAINER(ew->window), PREF_PAD_BORDER);
 201
 202         win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
 203         gtk_container_add(GTK_CONTAINER(ew->window), win_vbox);
 204         gtk_widget_show(win_vbox);
 205
 206         hbox = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
 207         gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
 208         gtk_widget_show(hbox);
 209
 210         ew->entry = gtk_entry_new();
 211         gtk_box_pack_start(GTK_BOX(hbox), ew->entry, TRUE, TRUE, 0);
 212         ew->desktop_name = NULL;
 213         if (desktop_name)
 214                 {
 215                 gtk_entry_set_text(GTK_ENTRY(ew->entry), desktop_name);
 216                 ew->desktop_name = g_strdup(desktop_name);
 217                 }
 218         gtk_widget_show(ew->entry);
 219         g_signal_connect(G_OBJECT(ew->entry), "changed", G_CALLBACK(editor_window_entry_changed_cb), ew);
 220
 221         button_hbox = gtk_hbutton_box_new();
 222         gtk_button_box_set_layout(GTK_BUTTON_BOX(button_hbox), GTK_BUTTONBOX_END);
 223         gtk_box_set_spacing(GTK_BOX(button_hbox), PREF_PAD_BUTTON_GAP);
 224         gtk_box_pack_end(GTK_BOX(hbox), button_hbox, FALSE, FALSE, 0);
 225         gtk_widget_show(button_hbox);
 226
 227         ew->save_button = pref_button_new(NULL, GTK_STOCK_SAVE, NULL, FALSE,
 228                                  G_CALLBACK(editor_window_save_cb), ew);
 229         gtk_container_add(GTK_CONTAINER(button_hbox), ew->save_button);
 230         gtk_widget_set_can_default(ew->save_button, TRUE);
 231         gtk_widget_set_sensitive(ew->save_button, FALSE);
 232         gtk_widget_show(ew->save_button);
 233         ct_button = ew->save_button;
 234
 235         button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
 236                                  G_CALLBACK(editor_window_close_cb), ew);
 237         gtk_container_add(GTK_CONTAINER(button_hbox), button);
 238         gtk_widget_set_can_default(button, TRUE);
 239         gtk_widget_show(button);
 240
 241         if (!generic_dialog_get_alternative_button_order(ew->window))
 242                 {
 243                 gtk_box_reorder_child(GTK_BOX(button_hbox), ct_button, -1);
 244                 }
 245
 246
 247         scrolled = gtk_scrolled_window_new(NULL, NULL);
 248         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
 249         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
 250                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 251         gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5);
 252         gtk_widget_show(scrolled);
 253
 254         text_view = gtk_text_view_new();
 255         gtk_container_add(GTK_CONTAINER(scrolled), text_view);
 256         gtk_widget_show(text_view);
 257
 258         ew->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
 259         if (g_file_get_contents(src_path, &text, &size, NULL))
 260                 {
 261                 gtk_text_buffer_set_text(ew->buffer, text, size);
 262                 }
 263         gtk_text_buffer_set_modified(ew->buffer, FALSE);
 264         g_signal_connect(G_OBJECT(ew->buffer), "modified-changed",
 265                          G_CALLBACK(editor_window_text_modified_cb), ew);
 266
 267         gtk_widget_show(ew->window);
 268 }
 269
 270
 271 static void editor_list_window_close_cb(GtkWidget *widget, gpointer data)
 272 {
 273         gtk_widget_destroy(editor_list_window->window);
 274         g_free(editor_list_window);
 275         editor_list_window = NULL;
 276 }
 277
 278 static gboolean editor_list_window_delete(GtkWidget *widget, GdkEventAny *event, gpointer data)
 279 {
 280         editor_list_window_close_cb(NULL, NULL);
 281         return TRUE;
 282 }
 283
 284 static void editor_list_window_delete_dlg_cancel(GenericDialog *gd, gpointer data);
 285
 286 static void editor_list_window_delete_dlg_cancel(GenericDialog *gd, gpointer data)
 287 {
 288         EditorWindowDel_Data *ewdl = data;
 289
 290         ewdl->ewl->gd = NULL;
 291         g_free(ewdl->path);
 292         g_free(ewdl);
 293 }
 294
 295 static void editor_list_window_delete_dlg_ok_cb(GenericDialog *gd, gpointer data)
 296 {
 297         EditorWindowDel_Data *ewdl = data;
 298
 299         if (!unlink_file(ewdl->path))
 300                 {
 301                 gchar *text = g_strdup_printf(_("Unable to delete file:\n%s"), ewdl->path);
 302                 warning_dialog(_("File deletion failed"), text, GTK_STOCK_DIALOG_WARNING, NULL);
 303                 g_free(text);
 304                 }
 305         else
 306                 {
 307                 /* refresh list */
 308                 layout_editors_reload_start();
 309                 /* idle function is not needed, everything should be cached */
 310                 layout_editors_reload_finish();
 311                 }
 312
 313         editor_list_window_delete_dlg_cancel(gd, data);
 314 }
 315
 316 static void editor_list_window_delete_cb(GtkWidget *widget, gpointer data)
 317 {
 318         EditorListWindow *ewl = data;
 319         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
 320         GtkTreeIter iter;
 321
 322         if (gtk_tree_selection_get_selected(sel, NULL, &iter))
 323                 {
 324                 GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
 325                 gchar *path;
 326                 gchar *key;
 327                 gchar *text;
 328                 EditorWindowDel_Data *ewdl;
 329
 330                 gtk_tree_model_get(store, &iter,
 331                                    DESKTOP_FILE_COLUMN_PATH, &path,
 332                                    DESKTOP_FILE_COLUMN_KEY, &key, -1);
 333
 334
 335                 ewdl = g_new(EditorWindowDel_Data, 1);
 336                 ewdl->ewl = ewl;
 337                 ewdl->path = path;
 338
 339                 if (ewl->gd)
 340                         {
 341                         GenericDialog *gd = ewl->gd;
 342                         editor_list_window_delete_dlg_cancel(ewl->gd, ewl->gd->data);
 343                         generic_dialog_close(gd);
 344                         }
 345
 346                 ewl->gd = generic_dialog_new(_("Delete file"), "dlg_confirm",
 347                                             NULL, TRUE,
 348                                             editor_list_window_delete_dlg_cancel, ewdl);
 349
 350                 generic_dialog_add_button(ewl->gd, GTK_STOCK_DELETE, NULL, editor_list_window_delete_dlg_ok_cb, TRUE);
 351
 352                 text = g_strdup_printf(_("About to delete the file:\n %s"), path);
 353                 generic_dialog_add_message(ewl->gd, GTK_STOCK_DIALOG_QUESTION,
 354                                            _("Delete file"), text, TRUE);
 355                 g_free(text);
 356
 357                 gtk_widget_show(ewl->gd->dialog);
 358                 }
 359 }
 360
 361 static void editor_list_window_edit_cb(GtkWidget *widget, gpointer data)
 362 {
 363         EditorListWindow *ewl = data;
 364         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
 365         GtkTreeIter iter;
 366
 367         if (gtk_tree_selection_get_selected(sel, NULL, &iter))
 368                 {
 369                 GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
 370                 gchar *path;
 371                 gchar *key;
 372
 373                 gtk_tree_model_get(store, &iter,
 374                                    DESKTOP_FILE_COLUMN_PATH, &path,
 375                                    DESKTOP_FILE_COLUMN_KEY, &key, -1);
 376                 editor_window_new(path, key);
 377                 g_free(key);
 378                 g_free(path);
 379                 }
 380 }
 381
 382 static void editor_list_window_new_cb(GtkWidget *widget, gpointer data)
 383 {
 384         editor_window_new(desktop_file_template, _("new.desktop"));
 385 }
 386
 387 static void editor_list_window_help_cb(GtkWidget *widget, gpointer data)
 388 {
 389         help_window_show("GuidePluginsConfig.html");
 390 }
 391
 392 static void editor_list_window_selection_changed_cb(GtkWidget *widget, gpointer data)
 393 {
 394         EditorListWindow *ewl = data;
 395         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
 396         GtkTreeIter iter;
 397
 398         if (gtk_tree_selection_get_selected(sel, NULL, &iter))
 399                 {
 400                 GtkTreeModel *store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
 401                 gchar *path;
 402
 403                 gtk_tree_model_get(store, &iter,
 404                                                    DESKTOP_FILE_COLUMN_PATH, &path,
 405                                                    -1);
 406
 407                 gtk_widget_set_sensitive(ewl->delete_button, access_file(path, W_OK));
 408                 gtk_widget_set_sensitive(ewl->edit_button, TRUE);
 409                 g_free(path);
 410                 }
 411
 412 }
 413
 414 static gint editor_list_window_sort_cb(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer data)
 415 {
 416         gint n = GPOINTER_TO_INT(data);
 417         gint ret = 0;
 418         gboolean bool1, bool2;
 419
 420         switch (n)
 421                 {
 422                 case DESKTOP_FILE_COLUMN_KEY:
 423                 case DESKTOP_FILE_COLUMN_NAME:
 424                 case DESKTOP_FILE_COLUMN_PATH:
 425                 case DESKTOP_FILE_COLUMN_HIDDEN:
 426                         {
 427                         gchar *s1, *s2;
 428
 429                         gtk_tree_model_get(model, a, n, &s1, -1);
 430                         gtk_tree_model_get(model, b, n, &s2, -1);
 431
 432                         if (!s1 || !s2)
 433                                 {
 434                                 if (!s1 && !s2) break;
 435                                 ret = s1 ? 1 : -1;
 436                                 }
 437                         else
 438                                 {
 439                                 ret = g_utf8_collate(s1, s2);
 440                                 }
 441
 442                         g_free(s1);
 443                         g_free(s2);
 444                         }
 445                         break;
 446                 case DESKTOP_FILE_COLUMN_DISABLED:
 447                         {
 448                         gtk_tree_model_get(model, a, n, &bool1, -1);
 449                         gtk_tree_model_get(model, b, n, &bool2, -1);
 450
 451                         if (bool1 == bool2)
 452                                 {
 453                                 ret = 0;
 454                                 }
 455                         else if (bool1 > bool2)
 456                                 {
 457                                 ret = -1;
 458                                 }
 459                         else
 460                                 {
 461                                 ret = 1;
 462                                 }
 463                         break;
 464                         }
 465
 466                 default:
 467                         g_return_val_if_reached(0);
 468                 }
 469
 470         return ret;
 471 }
 472
 473 static void plugin_disable_cb(GtkCellRendererToggle *renderer, gchar *path_str, gpointer data)
 474 {
 475         EditorListWindow *ewl = data;
 476         GtkTreePath *tpath;
 477         GtkTreeIter iter;
 478         GtkTreeModel *model;
 479         gboolean disabled;
 480         gchar *path;
 481         GList *list;
 482         gchar *haystack;
 483
 484         tpath = gtk_tree_path_new_from_string(path_str);
 485         model = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
 486         gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, tpath);
 487         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, DESKTOP_FILE_COLUMN_DISABLED, &disabled, -1);
 488         gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, DESKTOP_FILE_COLUMN_PATH, &path, -1);
 489
 490         gtk_list_store_set(GTK_LIST_STORE(desktop_file_list), &iter, DESKTOP_FILE_COLUMN_DISABLED, !disabled, -1);
 491
 492         if (!disabled)
 493                 {
 494                 options->disabled_plugins = g_list_append((options->disabled_plugins), g_strdup(path));
 495                 }
 496         else
 497                 {
 498                 list = options->disabled_plugins;
 499                 while (list)
 500                         {
 501                         haystack = list->data;
 502
 503                         if (haystack && strcmp(haystack, path) == 0)
 504                                 {
 505                                 g_free(haystack);
 506                                 options->disabled_plugins = g_list_remove(options->disabled_plugins, haystack);
 507                                 }
 508
 509                         list = list->next;
 510                         }
 511                 }
 512
 513         layout_editors_reload_start();
 514         layout_editors_reload_finish();
 515 }
 516
 517 static void plugin_disable_set_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
 518                                                         GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
 519 {
 520         gboolean disabled;
 521
 522         gtk_tree_model_get(tree_model, iter, DESKTOP_FILE_COLUMN_DISABLED, &disabled, -1);
 523
 524         if (disabled)
 525                 {
 526                 g_object_set(GTK_CELL_RENDERER(cell), "active", TRUE, NULL);
 527                 }
 528         else
 529                 {
 530                 g_object_set(GTK_CELL_RENDERER(cell), "active", FALSE, NULL);
 531                 }
 532 }
 533
 534 static void editor_list_window_create(void)
 535 {
 536         GtkWidget *win_vbox;
 537         GtkWidget *hbox;
 538         GtkWidget *button;
 539         GtkWidget *scrolled;
 540         GtkCellRenderer *renderer;
 541         GtkTreeSelection *selection;
 542         GtkTreeViewColumn *column;
 543         GtkTreeModel *store;
 544         GtkTreeSortable *sortable;
 545         EditorListWindow *ewl;
 546
 547         editor_list_window = ewl = g_new0(EditorListWindow, 1);
 548
 549         ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Plugins"));
 550         DEBUG_NAME(ewl->window);
 551         gtk_window_set_type_hint(GTK_WINDOW(ewl->window), GDK_WINDOW_TYPE_HINT_DIALOG);
 552         g_signal_connect(G_OBJECT(ewl->window), "delete_event",
 553                          G_CALLBACK(editor_list_window_delete), NULL);
 554         gtk_window_set_default_size(GTK_WINDOW(ewl->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
 555         gtk_window_set_resizable(GTK_WINDOW(ewl->window), TRUE);
 556         gtk_container_set_border_width(GTK_CONTAINER(ewl->window), PREF_PAD_BORDER);
 557
 558         win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
 559         gtk_container_add(GTK_CONTAINER(ewl->window), win_vbox);
 560         gtk_widget_show(win_vbox);
 561
 562         hbox = gtk_hbutton_box_new();
 563         gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
 564         gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
 565         gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
 566         gtk_widget_show(hbox);
 567
 568
 569         button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
 570                                  G_CALLBACK(editor_list_window_help_cb), ewl);
 571         gtk_container_add(GTK_CONTAINER(hbox), button);
 572         gtk_widget_set_can_default(button, TRUE);
 573         gtk_widget_show(button);
 574
 575         button = pref_button_new(NULL, GTK_STOCK_NEW, NULL, FALSE,
 576                                  G_CALLBACK(editor_list_window_new_cb), ewl);
 577         gtk_container_add(GTK_CONTAINER(hbox), button);
 578         gtk_widget_set_can_default(button, TRUE);
 579         gtk_widget_show(button);
 580
 581         button = pref_button_new(NULL, GTK_STOCK_EDIT, NULL, FALSE,
 582                                  G_CALLBACK(editor_list_window_edit_cb), ewl);
 583         gtk_container_add(GTK_CONTAINER(hbox), button);
 584         gtk_widget_set_can_default(button, TRUE);
 585         gtk_widget_set_sensitive(button, FALSE);
 586         gtk_widget_show(button);
 587         ewl->edit_button = button;
 588
 589         button = pref_button_new(NULL, GTK_STOCK_DELETE, NULL, FALSE,
 590                                  G_CALLBACK(editor_list_window_delete_cb), ewl);
 591         gtk_container_add(GTK_CONTAINER(hbox), button);
 592         gtk_widget_set_can_default(button, TRUE);
 593         gtk_widget_set_sensitive(button, FALSE);
 594         gtk_widget_show(button);
 595         ewl->delete_button = button;
 596
 597         button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
 598                                  G_CALLBACK(editor_list_window_close_cb), ewl);
 599         gtk_container_add(GTK_CONTAINER(hbox), button);
 600         gtk_widget_set_can_default(button, TRUE);
 601         gtk_widget_show(button);
 602
 603         scrolled = gtk_scrolled_window_new(NULL, NULL);
 604         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
 605         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
 606                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 607         gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5);
 608         gtk_widget_show(scrolled);
 609
 610         ewl->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(desktop_file_list));
 611         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
 612         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
 613         g_signal_connect(selection, "changed", G_CALLBACK(editor_list_window_selection_changed_cb), ewl);
 614
 615         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ewl->view), FALSE);
 616
 617         column = gtk_tree_view_column_new();
 618         gtk_tree_view_column_set_title(column, _("Disabled"));
 619         gtk_tree_view_column_set_resizable(column, TRUE);
 620
 621         renderer = gtk_cell_renderer_toggle_new();
 622         g_signal_connect(G_OBJECT(renderer), "toggled",
 623                          G_CALLBACK(plugin_disable_cb), ewl);
 624         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 625         gtk_tree_view_column_set_cell_data_func(column, renderer, plugin_disable_set_func,
 626                                                 NULL, NULL);
 627         gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
 628         gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_DISABLED);
 629
 630         column = gtk_tree_view_column_new();
 631         gtk_tree_view_column_set_title(column, _("Name"));
 632         gtk_tree_view_column_set_resizable(column, TRUE);
 633         renderer = gtk_cell_renderer_text_new();
 634         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 635         gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_NAME);
 636         gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
 637         gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_NAME);
 638
 639         column = gtk_tree_view_column_new();
 640         gtk_tree_view_column_set_title(column, _("Hidden"));
 641         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 642         renderer = gtk_cell_renderer_text_new();
 643         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 644         gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_HIDDEN);
 645         gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
 646         gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_HIDDEN);
 647         gtk_tree_view_column_set_alignment(column, 0.5);
 648
 649         column = gtk_tree_view_column_new();
 650         gtk_tree_view_column_set_title(column, _("Desktop file"));
 651         gtk_tree_view_column_set_resizable(column, TRUE);
 652         renderer = gtk_cell_renderer_text_new();
 653         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 654         gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_KEY);
 655         gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
 656         gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_KEY);
 657
 658         column = gtk_tree_view_column_new();
 659         gtk_tree_view_column_set_title(column, _("Path"));
 660         gtk_tree_view_column_set_resizable(column, TRUE);
 661         renderer = gtk_cell_renderer_text_new();
 662         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 663         gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_PATH);
 664         gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
 665         gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_PATH);
 666
 667         /* set up sorting */
 668         store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
 669         sortable = GTK_TREE_SORTABLE(store);
 670         gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_KEY, editor_list_window_sort_cb,
 671                                         GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), NULL);
 672         gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_HIDDEN, editor_list_window_sort_cb,
 673                                         GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), NULL);
 674         gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_NAME, editor_list_window_sort_cb,
 675                                         GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), NULL);
 676         gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_PATH, editor_list_window_sort_cb,
 677                                         GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), NULL);
 678         gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_DISABLED, editor_list_window_sort_cb,
 679                                         GINT_TO_POINTER(DESKTOP_FILE_COLUMN_DISABLED), NULL);
 680
 681         /* set initial sort order */
 682     gtk_tree_sortable_set_sort_column_id(sortable, DESKTOP_FILE_COLUMN_NAME, GTK_SORT_ASCENDING);
 683
 684         gtk_container_add(GTK_CONTAINER(scrolled), ewl->view);
 685         gtk_widget_show(ewl->view);
 686
 687         gtk_widget_show(ewl->window);
 688 }
 689
 690 /*
 691  *-----------------------------------------------------------------------------
 692  * config window show (public)
 693  *-----------------------------------------------------------------------------
 694  */
 695
 696 void show_editor_list_window(void)
 697 {
 698         if (editor_list_window)
 699                 {
 700                 gtk_window_present(GTK_WINDOW(editor_list_window));
 701                 return;
 702                 }
 703
 704         editor_list_window_create();
 705 }
 706 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */