← Back to branch summary

~ubuntu-branches/ubuntu/utopic/geany/utopic

« back to all changes in this revision

Viewing changes to src/tools.c

  • Committer: Package Import Robot
  • Author(s): Chow Loong Jin
  • Date: 2011-12-10 07:43:26 UTC
  • mfrom: (3.3.7 sid)
  • Revision ID: package-import@ubuntu.com-20111210074326-s8yqbew5i20h33tf
Tags: 0.21-1ubuntu1
* Merge from Debian Unstable, remaining changes:
  - debian/patches/20_use_evince_viewer.patch:
     + use evince as viewer for pdf and dvi files
  - debian/patches/20_use_x_terminal_emulator.patch:
     + use x-terminal-emulator as terminal
  - debian/control
     + Add breaks on geany-plugins-common << 0.20
* Also fixes bugs:
  - Filter for MATLAB/Octave files filters everythign (LP: 885505)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tools.c
1
1
/*
2
2
 *      tools.c - this file is part of Geany, a fast and lightweight IDE
3
3
 *
4
 
 *      Copyright 2006-2010 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
5
 
 *      Copyright 2006-2010 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
 
4
 *      Copyright 2006-2011 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
 
5
 *      Copyright 2006-2011 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
6
6
 *
7
7
 *      This program is free software; you can redistribute it and/or modify
8
8
 *      it under the terms of the GNU General Public License as published by
18
18
 *      along with this program; if not, write to the Free Software
19
19
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20
20
 *
21
 
 * $Id: tools.c 5268 2010-10-01 12:43:32Z ntrel $
 
21
 * $Id: tools.c 5886 2011-08-06 18:34:14Z colombanw $
22
22
 */
23
23
 
24
24
/*
53
53
#include "dialogs.h"
54
54
 
55
55
 
 
56
enum
 
57
{
 
58
        CC_COLUMN_ID,
 
59
        CC_COLUMN_STATUS,
 
60
        CC_COLUMN_TOOLTIP,
 
61
        CC_COLUMN_CMD,
 
62
        CC_COLUMN_COUNT
 
63
};
 
64
 
56
65
/* custom commands code*/
57
66
struct cc_dialog
58
67
{
59
 
        gint count;
60
 
        GtkWidget *box;
 
68
        guint count;
 
69
        GtkWidget *view;
 
70
        GtkTreeViewColumn *edit_column;
 
71
        GtkListStore *store;
 
72
        GtkTreeSelection *selection;
 
73
        GtkWidget *button_add;
 
74
        GtkWidget *button_remove;
 
75
        GtkWidget *button_up;
 
76
        GtkWidget *button_down;
61
77
};
62
78
 
63
79
static gboolean cc_error_occurred = FALSE;
64
80
static gboolean cc_reading_finished = FALSE;
65
81
static GString *cc_buffer;
66
82
 
67
 
static void cc_add_command(struct cc_dialog *cc, gint idx)
68
 
{
69
 
        GtkWidget *label, *entry, *hbox;
70
 
        gchar str[6];
71
 
 
72
 
        hbox = gtk_hbox_new(FALSE, 5);
73
 
        g_snprintf(str, 5, "%d:", cc->count);
74
 
        label = gtk_label_new(str);
75
 
 
76
 
        entry = gtk_entry_new();
77
 
        if (idx >= 0)
78
 
                gtk_entry_set_text(GTK_ENTRY(entry), ui_prefs.custom_commands[idx]);
79
 
        ui_entry_add_clear_icon(GTK_ENTRY(entry));
80
 
        gtk_entry_set_max_length(GTK_ENTRY(entry), 255);
81
 
        gtk_entry_set_width_chars(GTK_ENTRY(entry), 30);
82
 
        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
83
 
        gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
84
 
        gtk_widget_show_all(hbox);
85
 
        gtk_container_add(GTK_CONTAINER(cc->box), hbox);
 
83
 
 
84
static gboolean cc_exists_command(const gchar *command)
 
85
{
 
86
        gchar *path = g_find_program_in_path(command);
 
87
 
 
88
        g_free(path);
 
89
 
 
90
        return path != NULL;
 
91
}
 
92
 
 
93
 
 
94
/* update STATUS and TOOLTIP columns according to cmd */
 
95
static void cc_dialog_update_row_status(GtkListStore *store, GtkTreeIter *iter, const gchar *cmd)
 
96
{
 
97
        GError *err = NULL;
 
98
        const gchar *stock_id = GTK_STOCK_NO;
 
99
        gchar *tooltip = NULL;
 
100
        gint argc;
 
101
        gchar **argv;
 
102
 
 
103
        if (! NZV(cmd))
 
104
                stock_id = GTK_STOCK_YES;
 
105
        else if (g_shell_parse_argv(cmd, &argc, &argv, &err))
 
106
        {
 
107
                if (argc > 0 && cc_exists_command(argv[0]))
 
108
                        stock_id = GTK_STOCK_YES;
 
109
                else
 
110
                        tooltip = g_strdup_printf(_("Invalid command: %s"), _("Command not found"));
 
111
                g_strfreev(argv);
 
112
        }
 
113
        else
 
114
        {
 
115
                tooltip = g_strdup_printf(_("Invalid command: %s"), err->message);
 
116
                g_error_free(err);
 
117
        }
 
118
 
 
119
        gtk_list_store_set(store, iter, CC_COLUMN_STATUS, stock_id, CC_COLUMN_TOOLTIP, tooltip, -1);
 
120
        g_free(tooltip);
 
121
}
 
122
 
 
123
 
 
124
/* adds a new row for custom command @p idx, or an new empty one if < 0 */
 
125
static void cc_dialog_add_command(struct cc_dialog *cc, gint idx, gboolean start_editing)
 
126
{
 
127
        GtkTreeIter iter;
 
128
        const gchar *cmd;
 
129
        guint id = cc->count;
 
130
 
 
131
        cmd = (idx >= 0) ? ui_prefs.custom_commands[idx] : NULL;
 
132
 
86
133
        cc->count++;
87
 
}
88
 
 
89
 
 
90
 
static void cc_on_custom_commands_dlg_add_clicked(GtkToolButton *toolbutton, struct cc_dialog *cc)
91
 
{
92
 
        cc_add_command(cc, -1);
 
134
        gtk_list_store_append(cc->store, &iter);
 
135
        gtk_list_store_set(cc->store, &iter, CC_COLUMN_ID, id, CC_COLUMN_CMD, cmd, -1);
 
136
        cc_dialog_update_row_status(cc->store, &iter, cmd);
 
137
 
 
138
        if (start_editing)
 
139
        {
 
140
                GtkTreePath *path;
 
141
 
 
142
                gtk_widget_grab_focus(cc->view);
 
143
                path = gtk_tree_model_get_path(GTK_TREE_MODEL(cc->store), &iter);
 
144
                gtk_tree_view_set_cursor(GTK_TREE_VIEW(cc->view), path, cc->edit_column, TRUE);
 
145
                gtk_tree_path_free(path);
 
146
        }
 
147
}
 
148
 
 
149
 
 
150
static void cc_on_dialog_add_clicked(GtkButton *button, struct cc_dialog *cc)
 
151
{
 
152
        cc_dialog_add_command(cc, -1, TRUE);
 
153
}
 
154
 
 
155
 
 
156
static void cc_on_dialog_remove_clicked(GtkButton *button, struct cc_dialog *cc)
 
157
{
 
158
        GtkTreeIter iter;
 
159
 
 
160
        if (gtk_tree_selection_get_selected(cc->selection, NULL, &iter))
 
161
                gtk_list_store_remove(cc->store, &iter);
 
162
}
 
163
 
 
164
 
 
165
static void cc_on_dialog_move_up_clicked(GtkButton *button, struct cc_dialog *cc)
 
166
{
 
167
        GtkTreeIter iter;
 
168
 
 
169
        if (gtk_tree_selection_get_selected(cc->selection, NULL, &iter))
 
170
        {
 
171
                GtkTreePath *path;
 
172
                GtkTreeIter prev;
 
173
 
 
174
                path = gtk_tree_model_get_path(GTK_TREE_MODEL(cc->store), &iter);
 
175
                if (gtk_tree_path_prev(path) &&
 
176
                        gtk_tree_model_get_iter(GTK_TREE_MODEL(cc->store), &prev, path))
 
177
                {
 
178
                        gtk_list_store_move_before(cc->store, &iter, &prev);
 
179
                }
 
180
                gtk_tree_path_free(path);
 
181
        }
 
182
}
 
183
 
 
184
 
 
185
static void cc_on_dialog_move_down_clicked(GtkButton *button, struct cc_dialog *cc)
 
186
{
 
187
        GtkTreeIter iter;
 
188
 
 
189
        if (gtk_tree_selection_get_selected(cc->selection, NULL, &iter))
 
190
        {
 
191
                GtkTreeIter next = iter;
 
192
 
 
193
                if (gtk_tree_model_iter_next(GTK_TREE_MODEL(cc->store), &next))
 
194
                        gtk_list_store_move_after(cc->store, &iter, &next);
 
195
        }
93
196
}
94
197
 
95
198
 
240
343
        g_return_if_fail(doc != NULL && command != NULL);
241
344
 
242
345
        if (! sci_has_selection(doc->editor->sci))
243
 
                return;
 
346
                editor_select_lines(doc->editor, FALSE);
244
347
 
245
348
        if (!g_shell_parse_argv(command, NULL, &argv, &error))
246
349
        {
300
403
}
301
404
 
302
405
 
 
406
static void cc_dialog_on_command_edited(GtkCellRendererText *renderer, gchar *path, gchar *text,
 
407
                struct cc_dialog *cc)
 
408
{
 
409
        GtkTreeIter iter;
 
410
 
 
411
        gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(cc->store), &iter, path);
 
412
        gtk_list_store_set(cc->store, &iter, CC_COLUMN_CMD, text, -1);
 
413
        cc_dialog_update_row_status(cc->store, &iter, text);
 
414
}
 
415
 
 
416
 
 
417
/* re-compute IDs to reflect the current store state */
 
418
static void cc_dialog_update_ids(struct cc_dialog *cc)
 
419
{
 
420
        GtkTreeIter iter;
 
421
 
 
422
        cc->count = 1;
 
423
        if (! gtk_tree_model_get_iter_first(GTK_TREE_MODEL(cc->store), &iter))
 
424
                return;
 
425
 
 
426
        do
 
427
        {
 
428
                gtk_list_store_set(cc->store, &iter, CC_COLUMN_ID, cc->count, -1);
 
429
                cc->count++;
 
430
        }
 
431
        while (gtk_tree_model_iter_next(GTK_TREE_MODEL(cc->store), &iter));
 
432
}
 
433
 
 
434
 
 
435
/* update sensitiveness of the buttons according to the selection */
 
436
static void cc_dialog_update_sensitive(struct cc_dialog *cc)
 
437
{
 
438
        GtkTreeIter iter;
 
439
        gboolean has_selection = FALSE;
 
440
        gboolean first_selected = FALSE;
 
441
        gboolean last_selected = FALSE;
 
442
 
 
443
        if ((has_selection = gtk_tree_selection_get_selected(cc->selection, NULL, &iter)))
 
444
        {
 
445
                GtkTreePath *path;
 
446
                GtkTreePath *copy;
 
447
 
 
448
                path = gtk_tree_model_get_path(GTK_TREE_MODEL(cc->store), &iter);
 
449
                copy = gtk_tree_path_copy(path);
 
450
                first_selected = ! gtk_tree_path_prev(copy);
 
451
                gtk_tree_path_free(copy);
 
452
                gtk_tree_path_next(path);
 
453
                last_selected = ! gtk_tree_model_get_iter(GTK_TREE_MODEL(cc->store), &iter, path);
 
454
                gtk_tree_path_free(path);
 
455
        }
 
456
 
 
457
        gtk_widget_set_sensitive(cc->button_remove, has_selection);
 
458
        gtk_widget_set_sensitive(cc->button_up, has_selection && ! first_selected);
 
459
        gtk_widget_set_sensitive(cc->button_down, has_selection && ! last_selected);
 
460
}
 
461
 
 
462
 
 
463
static void cc_dialog_on_tree_selection_changed(GtkTreeSelection *selection, struct cc_dialog *cc)
 
464
{
 
465
        cc_dialog_update_sensitive(cc);
 
466
}
 
467
 
 
468
 
 
469
static void cc_dialog_on_row_inserted(GtkTreeModel *model, GtkTreePath  *path, GtkTreeIter *iter,
 
470
                struct cc_dialog *cc)
 
471
{
 
472
        cc_dialog_update_ids(cc);
 
473
        cc_dialog_update_sensitive(cc);
 
474
}
 
475
 
 
476
 
 
477
static void cc_dialog_on_row_deleted(GtkTreeModel *model, GtkTreePath  *path, struct cc_dialog *cc)
 
478
{
 
479
        cc_dialog_update_ids(cc);
 
480
        cc_dialog_update_sensitive(cc);
 
481
}
 
482
 
 
483
 
 
484
static void cc_dialog_on_rows_reordered(GtkTreeModel *model, GtkTreePath  *path, GtkTreeIter *iter,
 
485
                gpointer new_order, struct cc_dialog *cc)
 
486
{
 
487
        cc_dialog_update_ids(cc);
 
488
        cc_dialog_update_sensitive(cc);
 
489
}
 
490
 
 
491
 
303
492
static void cc_show_dialog_custom_commands(void)
304
493
{
305
 
        GtkWidget *dialog, *label, *vbox, *button;
 
494
        GtkWidget *dialog, *label, *vbox, *scroll, *buttonbox;
 
495
        GtkCellRenderer *renderer;
 
496
        GtkTreeViewColumn *column;
306
497
        guint i;
307
498
        struct cc_dialog cc;
308
499
 
309
500
        dialog = gtk_dialog_new_with_buttons(_("Set Custom Commands"), GTK_WINDOW(main_widgets.window),
310
501
                                                GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
311
502
                                                GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
 
503
        gtk_window_set_default_size(GTK_WINDOW(dialog), 300, 300); /* give a reasonable minimal default size */
312
504
        vbox = ui_dialog_vbox_new(GTK_DIALOG(dialog));
313
505
        gtk_box_set_spacing(GTK_BOX(vbox), 6);
314
506
        gtk_widget_set_name(dialog, "GeanyDialog");
316
508
        label = gtk_label_new(_("You can send the current selection to any of these commands and the output of the command replaces the current selection."));
317
509
        gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
318
510
        gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
319
 
        gtk_container_add(GTK_CONTAINER(vbox), label);
 
511
        gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
320
512
 
321
513
        cc.count = 1;
322
 
        cc.box = gtk_vbox_new(FALSE, 0);
323
 
        gtk_container_add(GTK_CONTAINER(vbox), cc.box);
324
 
 
325
 
        if (ui_prefs.custom_commands == NULL || g_strv_length(ui_prefs.custom_commands) == 0)
326
 
        {
327
 
                cc_add_command(&cc, -1);
328
 
        }
329
 
        else
330
 
        {
 
514
        cc.store = gtk_list_store_new(CC_COLUMN_COUNT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING,
 
515
                        G_TYPE_STRING);
 
516
        cc.view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(cc.store));
 
517
        gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(cc.view), CC_COLUMN_TOOLTIP);
 
518
        gtk_tree_view_set_reorderable(GTK_TREE_VIEW(cc.view), TRUE);
 
519
        cc.selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(cc.view));
 
520
        /* ID column */
 
521
        renderer = gtk_cell_renderer_text_new();
 
522
        column = gtk_tree_view_column_new_with_attributes(_("ID"), renderer, "text", CC_COLUMN_ID, NULL);
 
523
        gtk_tree_view_append_column(GTK_TREE_VIEW(cc.view), column);
 
524
        /* command column, holding status and command display */
 
525
        column = gtk_tree_view_column_new();
 
526
        gtk_tree_view_column_set_title(column, _("Command"));
 
527
        renderer = gtk_cell_renderer_pixbuf_new();
 
528
        gtk_tree_view_column_pack_start(column, renderer, FALSE);
 
529
        gtk_tree_view_column_set_attributes(column, renderer, "stock-id", CC_COLUMN_STATUS, NULL);
 
530
        renderer = gtk_cell_renderer_text_new();
 
531
        g_object_set(renderer, "editable", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 
532
        g_signal_connect(renderer, "edited", G_CALLBACK(cc_dialog_on_command_edited), &cc);
 
533
        gtk_tree_view_column_pack_start(column, renderer, TRUE);
 
534
        gtk_tree_view_column_set_attributes(column, renderer, "text", CC_COLUMN_CMD, NULL);
 
535
        cc.edit_column = column;
 
536
        gtk_tree_view_append_column(GTK_TREE_VIEW(cc.view), column);
 
537
 
 
538
        scroll = gtk_scrolled_window_new(NULL, NULL);
 
539
        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC,
 
540
                        GTK_POLICY_AUTOMATIC);
 
541
        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_IN);
 
542
        gtk_container_add(GTK_CONTAINER(scroll), cc.view);
 
543
        gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0);
 
544
 
 
545
        if (ui_prefs.custom_commands != NULL)
 
546
        {
 
547
                GtkTreeIter iter;
331
548
                guint len = g_strv_length(ui_prefs.custom_commands);
 
549
 
332
550
                for (i = 0; i < len; i++)
333
551
                {
334
 
                        if (ui_prefs.custom_commands[i][0] == '\0')
 
552
                        if (! NZV(ui_prefs.custom_commands[i]))
335
553
                                continue; /* skip empty fields */
336
554
 
337
 
                        cc_add_command(&cc, i);
 
555
                        cc_dialog_add_command(&cc, i, FALSE);
 
556
                }
 
557
 
 
558
                /* focus the first row if any */
 
559
                if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(cc.store), &iter))
 
560
                {
 
561
                        GtkTreePath *path = gtk_tree_model_get_path(GTK_TREE_MODEL(cc.store), &iter);
 
562
 
 
563
                        gtk_tree_view_set_cursor(GTK_TREE_VIEW(cc.view), path, cc.edit_column, FALSE);
 
564
                        gtk_tree_path_free(path);
338
565
                }
339
566
        }
340
567
 
341
 
        button = gtk_button_new_from_stock("gtk-add");
342
 
        g_signal_connect(button, "clicked", G_CALLBACK(cc_on_custom_commands_dlg_add_clicked), &cc);
343
 
        gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
 
568
        buttonbox = gtk_hbutton_box_new();
 
569
        gtk_box_set_spacing(GTK_BOX(buttonbox), 6);
 
570
        gtk_box_pack_start(GTK_BOX(vbox), buttonbox, FALSE, FALSE, 0);
 
571
        cc.button_add = gtk_button_new_from_stock(GTK_STOCK_ADD);
 
572
        g_signal_connect(cc.button_add, "clicked", G_CALLBACK(cc_on_dialog_add_clicked), &cc);
 
573
        gtk_container_add(GTK_CONTAINER(buttonbox), cc.button_add);
 
574
        cc.button_remove = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
 
575
        g_signal_connect(cc.button_remove, "clicked", G_CALLBACK(cc_on_dialog_remove_clicked), &cc);
 
576
        gtk_container_add(GTK_CONTAINER(buttonbox), cc.button_remove);
 
577
        cc.button_up = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
 
578
        g_signal_connect(cc.button_up, "clicked", G_CALLBACK(cc_on_dialog_move_up_clicked), &cc);
 
579
        gtk_container_add(GTK_CONTAINER(buttonbox), cc.button_up);
 
580
        cc.button_down = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
 
581
        g_signal_connect(cc.button_down, "clicked", G_CALLBACK(cc_on_dialog_move_down_clicked), &cc);
 
582
        gtk_container_add(GTK_CONTAINER(buttonbox), cc.button_down);
 
583
 
 
584
        cc_dialog_update_sensitive(&cc);
 
585
 
 
586
        /* only connect the selection signal when all other cc_dialog fields are set */
 
587
        g_signal_connect(cc.selection, "changed", G_CALLBACK(cc_dialog_on_tree_selection_changed), &cc);
 
588
        g_signal_connect(cc.store, "row-inserted", G_CALLBACK(cc_dialog_on_row_inserted), &cc);
 
589
        g_signal_connect(cc.store, "row-deleted", G_CALLBACK(cc_dialog_on_row_deleted), &cc);
 
590
        g_signal_connect(cc.store, "rows-reordered", G_CALLBACK(cc_dialog_on_rows_reordered), &cc);
344
591
 
345
592
        gtk_widget_show_all(vbox);
346
593
 
347
594
        if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
348
595
        {
349
 
                /* get all hboxes which contain a label and an entry element */
350
 
                GList *children = gtk_container_get_children(GTK_CONTAINER(cc.box));
351
 
                GList *node, *list;
352
596
                GSList *result_list = NULL;
353
 
                gint j = 0;
354
597
                gint len = 0;
355
598
                gchar **result = NULL;
356
 
                const gchar *text;
 
599
                GtkTreeIter iter;
357
600
 
358
 
                foreach_list(node, children)
 
601
                if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(cc.store), &iter))
359
602
                {
360
 
                        /* get the contents of each hbox */
361
 
                        list = gtk_container_get_children(GTK_CONTAINER(node->data));
362
 
 
363
 
                        /* first element of the list is the label, so skip it and get the entry element */
364
 
                        text = gtk_entry_get_text(GTK_ENTRY(list->next->data));
365
 
 
366
 
                        /* if the content of the entry is non-empty, add it to the result array */
367
 
                        if (text[0] != '\0')
 
603
                        do
368
604
                        {
369
 
                                result_list = g_slist_append(result_list, g_strdup(text));
370
 
                                len++;
 
605
                                gchar *cmd;
 
606
 
 
607
                                gtk_tree_model_get(GTK_TREE_MODEL(cc.store), &iter, CC_COLUMN_CMD, &cmd, -1);
 
608
                                if (NZV(cmd))
 
609
                                {
 
610
                                        result_list = g_slist_prepend(result_list, cmd);
 
611
                                        len++;
 
612
                                }
 
613
                                else
 
614
                                        g_free(cmd);
371
615
                        }
372
 
                        g_list_free(list);
 
616
                        while (gtk_tree_model_iter_next(GTK_TREE_MODEL(cc.store), &iter));
373
617
                }
374
 
                /* create a new null-terminated array but only if there any commands defined */
 
618
                result_list = g_slist_reverse(result_list);
 
619
                /* create a new null-terminated array but only if there is any commands defined */
375
620
                if (len > 0)
376
621
                {
 
622
                        gint j = 0;
 
623
                        GSList *node;
 
624
 
377
625
                        result = g_new(gchar*, len + 1);
378
 
                        while (result_list != NULL)
 
626
                        foreach_list(node, result_list)
379
627
                        {
380
 
                                result[j] = (gchar*) result_list->data;
381
 
 
382
 
                                result_list = result_list->next;
 
628
                                result[j] = (gchar*) node->data;
383
629
                                j++;
384
630
                        }
385
 
                        result[len] = NULL; /* null-terminate the array */
 
631
                        result[j] = NULL; /* null-terminate the array */
386
632
                }
387
633
                /* set the new array */
388
634
                g_strfreev(ui_prefs.custom_commands);
391
637
                tools_create_insert_custom_command_menu_items();
392
638
 
393
639
                g_slist_free(result_list);
394
 
                g_list_free(children);
395
640
        }
396
641
        gtk_widget_destroy(dialog);
397
642
}
398
643
 
399
644
 
400
 
/* enable or disable all custom command menu items when the sub menu is opened */
401
 
static void cc_on_custom_command_menu_activate(GtkMenuItem *menuitem, gpointer user_data)
402
 
{
403
 
        GeanyDocument *doc = document_get_current();
404
 
        gint i, len;
405
 
        gboolean enable;
406
 
        GList *children, *node;
407
 
 
408
 
        g_return_if_fail(doc != NULL);
409
 
 
410
 
        enable = sci_has_selection(doc->editor->sci) && (ui_prefs.custom_commands != NULL);
411
 
 
412
 
        children = gtk_container_get_children(GTK_CONTAINER(user_data));
413
 
        len = g_list_length(children);
414
 
        i = 0;
415
 
        foreach_list(node, children)
416
 
        {
417
 
                if (i == (len - 2))
418
 
                        break; /* stop before the last two elements (the seperator and the set entry) */
419
 
 
420
 
                gtk_widget_set_sensitive(GTK_WIDGET(node->data), enable);
421
 
                i++;
422
 
        }
423
 
        g_list_free(children);
424
 
}
425
 
 
426
 
 
427
645
static void cc_on_custom_command_activate(GtkMenuItem *menuitem, gpointer user_data)
428
646
{
429
647
        GeanyDocument *doc = document_get_current();
459
677
                case 2: key_idx = GEANY_KEYS_FORMAT_SENDTOCMD3; break;
460
678
        }
461
679
 
 
680
        item = gtk_menu_item_new_with_label(label);
462
681
        if (key_idx != -1)
 
682
        {
463
683
                kb = keybindings_lookup_item(GEANY_KEY_GROUP_FORMAT, key_idx);
464
 
 
465
 
        item = gtk_menu_item_new_with_label(label);
466
 
        if (key_idx != -1)
467
684
                gtk_widget_add_accelerator(item, "activate", gtk_accel_group_new(),
468
685
                        kb->key, kb->mods, GTK_ACCEL_VISIBLE);
 
686
        }
469
687
        gtk_container_add(GTK_CONTAINER(me), item);
470
688
        gtk_widget_show(item);
471
689
        g_signal_connect(item, "activate", G_CALLBACK(cc_on_custom_command_activate),
478
696
        GtkMenu *menu_edit = GTK_MENU(ui_lookup_widget(main_widgets.window, "send_selection_to2_menu"));
479
697
        GtkWidget *item;
480
698
        GList *me_children, *node;
481
 
        static gboolean signal_set = FALSE;
482
699
 
483
700
        /* first clean the menus to be able to rebuild them */
484
701
        me_children = gtk_container_get_children(GTK_CONTAINER(menu_edit));
514
731
        gtk_widget_show(item);
515
732
 
516
733
        cc_insert_custom_command_items(menu_edit, _("Set Custom Commands"), -1);
517
 
 
518
 
        if (! signal_set)
519
 
        {
520
 
                g_signal_connect(ui_lookup_widget(main_widgets.window, "send_selection_to2"),
521
 
                                        "activate", G_CALLBACK(cc_on_custom_command_menu_activate), menu_edit);
522
 
                signal_set = TRUE;
523
 
        }
524
734
}
525
735
 
526
736
 
583
793
        GtkWidget *dialog, *label, *vbox, *table;
584
794
        GeanyDocument *doc;
585
795
        guint chars = 0, lines = 0, words = 0;
586
 
        gchar *text, *range;
 
796
        gchar *text;
 
797
        const gchar *range;
587
798
 
588
799
        doc = document_get_current();
589
800
        g_return_if_fail(doc != NULL);
681
892
 */
682
893
#ifndef G_OS_WIN32
683
894
static void
684
 
on_color_cancel_button_clicked         (GtkButton       *button,
685
 
                                        gpointer         user_data)
 
895
on_color_cancel_button_clicked(GtkButton *button, gpointer user_data)
686
896
{
687
897
        gtk_widget_hide(ui_widgets.open_colorsel);
688
898
}
689
899
 
690
900
 
691
901
static void
692
 
on_color_ok_button_clicked             (GtkButton       *button,
693
 
                                        gpointer         user_data)
 
902
on_color_ok_button_clicked(GtkButton *button, gpointer user_data)
694
903
{
695
904
        GdkColor color;
696
905
        GeanyDocument *doc = document_get_current();