Debian Codegraph @

geanygendoc/src/ggd-widget-doctype-selector.c

raw
1 /*
2 *
3 * GeanyGenDoc, a Geany plugin to ease generation of source code documentation
4 * Copyright (C) 2010-2011 Colomban Wendling <[email protected]>
5 *
6 * This program 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 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
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
21 #ifdef HAVE_CONFIG_H
22 # include "config.h" /* for the gettext domain */
23 #endif
24
25 #include "ggd-widget-doctype-selector.h"
26
27 #include <gtk/gtk.h>
28
29 #include "ggd-plugin.h"
30
31
32 #if ! GTK_CHECK_VERSION (2, 20, 0) && ! defined(gtk_widget_get_realized)
33 # define gtk_widget_get_realized(w) (GTK_WIDGET_REALIZED (w))
34 #endif
35
36
37 static void ggd_doctype_selector_finalize (GObject *object);
38 static void ggd_doctype_selector_constructed (GObject *object);
39 static void doctype_column_edited_handler (GtkCellRendererText *renderer,
40 gchar *path,
41 gchar *new_text,
42 GtkListStore *store);
43 static gint sort_language_column (GtkTreeModel *model,
44 GtkTreeIter *a,
45 GtkTreeIter *b,
46 gpointer user_data);
47 static gboolean tree_view_button_press_event (GtkTreeView *view,
48 GdkEventButton *event,
49 GgdDoctypeSelector *selector);
50 static gboolean tree_view_popup_menu (GtkTreeView *view,
51 GgdDoctypeSelector *selector);
52 static void tree_view_popup_clear_handler (GtkMenuItem *item,
53 GgdDoctypeSelector *selector);
54 static void tree_view_popup_edit_handler (GtkMenuItem *item,
55 GgdDoctypeSelector *selector);
56
57
58 struct _GgdDoctypeSelectorPrivate
59 {
60 GtkListStore *store;
61 GtkWidget *view;
62 GtkWidget *popup_menu;
63 };
64
65 enum
66 {
67 /* Sort model column IDs in the order they are shown in the view for them to
68 * correspond to tree view's columns. Inivisible column at the end. */
69 COLUMN_LANGUAGE,
70 COLUMN_DOCTYPE,
71 COLUMN_ID,
72 COLUMN_TOOLTIP,
73
74 N_COLUMNS
75 };
76
77
78 G_DEFINE_TYPE (GgdDoctypeSelector, ggd_doctype_selector, GTK_TYPE_SCROLLED_WINDOW)
79
80
81 static void
82 ggd_doctype_selector_finalize (GObject *object)
83 {
84 GgdDoctypeSelector *self = GGD_DOCTYPE_SELECTOR (object);
85
86 g_object_unref (self->priv->store);
87
88 G_OBJECT_CLASS (ggd_doctype_selector_parent_class)->finalize (object);
89 }
90
91 static void
92 ggd_doctype_selector_class_init (GgdDoctypeSelectorClass *klass)
93 {
94 GObjectClass *object_class = G_OBJECT_CLASS (klass);
95
96 object_class->finalize = ggd_doctype_selector_finalize;
97 object_class->constructed = ggd_doctype_selector_constructed;
98
99 g_type_class_add_private (klass, sizeof (GgdDoctypeSelectorPrivate));
100 }
101
102 static void
103 ggd_doctype_selector_init (GgdDoctypeSelector *self)
104 {
105 GtkCellRenderer *renderer;
106 GtkTreeViewColumn *column;
107 GtkWidget *item;
108
109 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
110 GGD_TYPE_DOCTYPE_SELECTOR,
111 GgdDoctypeSelectorPrivate);
112 /* Set scrolled window properties */
113 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (self),
114 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
115 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (self),
116 GTK_SHADOW_IN);
117
118 /* Model */
119 self->priv->store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING,
120 G_TYPE_STRING, G_TYPE_UINT,
121 G_TYPE_STRING);
122 gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (self->priv->store),
123 COLUMN_LANGUAGE, sort_language_column,
124 NULL, NULL);
125 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->store),
126 COLUMN_LANGUAGE, GTK_SORT_ASCENDING);
127
128 /* View */
129 self->priv->view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->store));
130 gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->view), COLUMN_LANGUAGE);
131 gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (self->priv->view), COLUMN_TOOLTIP);
132 gtk_widget_show (self->priv->view);
133 /* language column */
134 renderer = gtk_cell_renderer_text_new ();
135 column = gtk_tree_view_column_new_with_attributes (_("Language"), renderer,
136 "text", COLUMN_LANGUAGE,
137 NULL);
138 gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->view), column);
139 /* doctype column */
140 renderer = gtk_cell_renderer_text_new ();
141 g_object_set (renderer, "editable", TRUE, NULL);
142 g_signal_connect (renderer, "edited",
143 G_CALLBACK (doctype_column_edited_handler), self->priv->store);
144 column = gtk_tree_view_column_new_with_attributes (_("Documentation type"), renderer,
145 "text", COLUMN_DOCTYPE,
146 NULL);
147 gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->view), column);
148
149 /* create popup menu */
150 self->priv->popup_menu = gtk_menu_new ();
151 g_signal_connect (self->priv->popup_menu, "deactivate",
152 G_CALLBACK (gtk_widget_hide), NULL);
153 gtk_menu_attach_to_widget (GTK_MENU (self->priv->popup_menu),
154 self->priv->view, NULL);
155 item = gtk_image_menu_item_new_with_mnemonic (_("_Change associated documentation type"));
156 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
157 gtk_image_new_from_stock (GTK_STOCK_EDIT,
158 GTK_ICON_SIZE_MENU));
159 g_signal_connect (item, "activate",
160 G_CALLBACK (tree_view_popup_edit_handler), self);
161 gtk_menu_shell_append (GTK_MENU_SHELL (self->priv->popup_menu), item);
162 gtk_widget_show (item);
163 item = gtk_image_menu_item_new_with_mnemonic (_("_Disassociate documentation type"));
164 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
165 gtk_image_new_from_stock (GTK_STOCK_CLEAR,
166 GTK_ICON_SIZE_MENU));
167 g_signal_connect (item, "activate",
168 G_CALLBACK (tree_view_popup_clear_handler), self);
169 gtk_menu_shell_append (GTK_MENU_SHELL (self->priv->popup_menu), item);
170 gtk_widget_show (item);
171 /* connect signals for popping the menu up */
172 g_signal_connect (self->priv->view, "button-press-event",
173 G_CALLBACK (tree_view_button_press_event), self);
174 g_signal_connect (self->priv->view, "popup-menu",
175 G_CALLBACK (tree_view_popup_menu), self);
176 }
177
178 static void
179 ggd_doctype_selector_constructed (GObject *object)
180 {
181 GgdDoctypeSelector *self = GGD_DOCTYPE_SELECTOR (object);
182 GtkTreeIter iter;
183 guint i;
184
185 /* Add the view after construction because GtkScrolledWindow needs its
186 * adjustments to be non-NULL, which is done by setting a property on
187 * construction. It perhaps should be fixed in GTK+? */
188 gtk_container_add (GTK_CONTAINER (self), self->priv->view);
189
190 /* add "All" on top of the list */
191 gtk_list_store_append (self->priv->store, &iter);
192 gtk_list_store_set (self->priv->store, &iter,
193 COLUMN_ID, 0,
194 COLUMN_LANGUAGE, _("All"),
195 COLUMN_TOOLTIP, _("Default documentation type for "
196 "languages that does not have one set"),
197 COLUMN_DOCTYPE, NULL,
198 -1);
199 /* i = 1: skip None */
200 for (i = 1; i < GEANY_MAX_BUILT_IN_FILETYPES; i++) {
201 gtk_list_store_append (self->priv->store, &iter);
202 gtk_list_store_set (self->priv->store, &iter,
203 COLUMN_ID, i,
204 COLUMN_LANGUAGE, filetypes[i]->name,
205 COLUMN_TOOLTIP, filetypes[i]->title,
206 COLUMN_DOCTYPE, NULL,
207 -1);
208 }
209 }
210
211 /* clears documentation type on the selected row */
212 static void
213 tree_view_popup_clear_handler (GtkMenuItem *item,
214 GgdDoctypeSelector *selector)
215 {
216 GtkTreeIter iter;
217 GtkTreeSelection *selection;
218
219 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (selector->priv->view));
220 if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
221 gtk_list_store_set (selector->priv->store, &iter, COLUMN_DOCTYPE, "", -1);
222 }
223 }
224
225 /* starts editing of the documentation type on the selected row */
226 static void
227 tree_view_popup_edit_handler (GtkMenuItem *item,
228 GgdDoctypeSelector *selector)
229 {
230 GtkTreeIter iter;
231 GtkTreeSelection *selection;
232 GtkTreeModel *model;
233 GtkTreeView *view = GTK_TREE_VIEW (selector->priv->view);
234
235 selection = gtk_tree_view_get_selection (view);
236 if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
237 GtkTreePath *path;
238 GtkTreeViewColumn *column;
239
240 path = gtk_tree_model_get_path (model, &iter);
241 column = gtk_tree_view_get_column (view, COLUMN_DOCTYPE);
242 gtk_tree_view_set_cursor_on_cell (view, path, column, NULL, TRUE);
243 gtk_tree_path_free (path);
244 }
245 }
246
247 static void
248 tree_view_popup_menu_position_func (GtkMenu *menu,
249 gint *x,
250 gint *y,
251 gboolean *push_in,
252 gpointer user_data)
253 {
254 GgdDoctypeSelector *selector = user_data;
255 GtkTreeView *view = GTK_TREE_VIEW (selector->priv->view);
256 GdkScreen *screen = gtk_widget_get_screen (selector->priv->view);
257 gint monitor_id;
258 GtkTreeModel *model;
259 GtkTreeViewColumn *column;
260 GtkTreeSelection *selection;
261 GtkTreePath *path;
262 GtkTreeIter iter;
263 GdkWindow *window;
264 GdkRectangle cell;
265 GdkRectangle monitor;
266 GtkRequisition req;
267
268 g_return_if_fail (gtk_widget_get_realized (selector->priv->view));
269
270 window = gtk_widget_get_window (GTK_WIDGET (view));
271 gdk_window_get_origin (window, x, y);
272 /* ensure there is a row selected */
273 selection = gtk_tree_view_get_selection (view);
274 if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
275 path = gtk_tree_model_get_path (model, &iter);
276 } else {
277 gtk_tree_view_get_cursor (view, &path, NULL);
278 gtk_tree_selection_select_path (selection, path);
279 }
280 column = gtk_tree_view_get_column (view, COLUMN_DOCTYPE);
281 gtk_tree_view_scroll_to_cell (view, path, column, FALSE, 0.0, 0.0);
282 gtk_tree_view_get_cell_area (view, path, column, &cell);
283 gtk_tree_path_free (path);
284 gtk_tree_view_convert_bin_window_to_widget_coords (view,
285 *x + cell.x, *y + cell.y,
286 x, y);
287 gtk_widget_size_request (GTK_WIDGET (menu), &req);
288 monitor_id = gdk_screen_get_monitor_at_point (screen, *x, *y);
289 gtk_menu_set_monitor (menu, monitor_id);
290 gdk_screen_get_monitor_geometry (screen, monitor_id, &monitor);
291 if (*y + cell.height + req.height <= monitor.height) {
292 *y += cell.height;
293 } else {
294 *y -= req.height;
295 }
296 *x = CLAMP (*x, monitor.x, monitor.x + MAX (0, monitor.width - req.width));
297 *y = CLAMP (*y, monitor.y, monitor.y + MAX (0, monitor.height - req.height));
298 *push_in = FALSE;
299 }
300
301 static void
302 do_popup_menu (GgdDoctypeSelector *self,
303 GdkEventButton *event)
304 {
305 guint event_button;
306 guint32 event_time;
307 GtkMenuPositionFunc menu_position_func;
308
309 if (event) {
310 event_button = event->button;
311 event_time = event->time;
312 menu_position_func = NULL;
313 } else {
314 event_button = 0;
315 event_time = gtk_get_current_event_time ();
316 menu_position_func = tree_view_popup_menu_position_func;
317 }
318 gtk_menu_popup (GTK_MENU (self->priv->popup_menu), NULL, NULL,
319 menu_position_func, self, event_button, event_time);
320 }
321
322 static gboolean
323 tree_view_button_press_event (GtkTreeView *view,
324 GdkEventButton *event,
325 GgdDoctypeSelector *selector)
326 {
327 gboolean handled = FALSE;
328
329 /* Ignore double-clicks and triple-clicks */
330 if (event->button == 3 && event->type == GDK_BUTTON_PRESS) {
331 GtkTreePath *path;
332
333 /* select row under the cursor before poping the menu up */
334 if (gtk_tree_view_get_path_at_pos (view, (gint)event->x, (gint)event->y,
335 &path, NULL, NULL, NULL)) {
336 gtk_tree_selection_select_path (gtk_tree_view_get_selection (view), path);
337 gtk_tree_view_scroll_to_cell (view, path, NULL, FALSE, 0.0, 0.0);
338 gtk_tree_path_free (path);
339 }
340 do_popup_menu (selector, event);
341 handled = TRUE;
342 }
343
344 return handled;
345 }
346
347 static gboolean
348 tree_view_popup_menu (GtkTreeView *view,
349 GgdDoctypeSelector *selector)
350 {
351 do_popup_menu (selector, NULL);
352
353 return TRUE;
354 }
355
356 /* Gets the row having @language_id as language ID.
357 * Returns: %TRUE if @iter was set, %FALSE otherwise */
358 static gboolean
359 get_row_iter (GgdDoctypeSelector *self,
360 guint language_id,
361 GtkTreeIter *iter)
362 {
363 gboolean valid;
364 GtkTreeModel *model = GTK_TREE_MODEL (self->priv->store);
365 gboolean found = FALSE;
366
367 valid = gtk_tree_model_get_iter_first (model, iter);
368 while (valid && ! found) {
369 guint id;
370
371 gtk_tree_model_get (model, iter, COLUMN_ID, &id, -1);
372 if (id == language_id) {
373 found = TRUE;
374 break;
375 }
376 valid = gtk_tree_model_iter_next (model, iter);
377 }
378
379 return found;
380 }
381
382 /* Updates the doctype of @language_id.
383 * Returns: %TRUE if @language_id was found (and updated), %FALSE otherwise */
384 static gboolean
385 update_doctype (GgdDoctypeSelector *self,
386 guint language_id,
387 const gchar *new_doctype)
388 {
389 GtkTreeIter iter;
390 gboolean changed = FALSE;
391
392 if (get_row_iter (self, language_id, &iter)) {
393 gtk_list_store_set (self->priv->store, &iter,
394 COLUMN_DOCTYPE, new_doctype,
395 -1);
396 changed = TRUE;
397 }
398
399 return changed;
400 }
401
402 /* Gets the value of a column of the row containing @language_id
403 * Returns: %TRUE if @result was set, %FALSE otherwise */
404 static gboolean
405 get_row_value (GgdDoctypeSelector *self,
406 guint language_id,
407 guint column,
408 void *result)
409 {
410 GtkTreeIter iter;
411 gboolean found = FALSE;
412
413 if (get_row_iter (self, language_id, &iter)) {
414 gtk_tree_model_get (GTK_TREE_MODEL (self->priv->store), &iter,
415 column, result,
416 -1);
417 found = TRUE;
418 }
419
420 return found;
421 }
422
423 static void
424 doctype_column_edited_handler (GtkCellRendererText *renderer,
425 gchar *path,
426 gchar *new_text,
427 GtkListStore *store)
428 {
429 GtkTreeIter iter;
430
431 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &iter, path);
432 gtk_list_store_set (store, &iter, COLUMN_DOCTYPE, new_text, -1);
433 }
434
435 /* GtkTreeIterCompareFunc to sort by the language column
436 * It keeps language ID 0 (All) on top. */
437 static gint
438 sort_language_column (GtkTreeModel *model,
439 GtkTreeIter *a,
440 GtkTreeIter *b,
441 gpointer user_data)
442 {
443 guint lang_id_1;
444 guint lang_id_2;
445 gchar *lang_name_1;
446 gchar *lang_name_2;
447 gint ret = 0;
448
449 gtk_tree_model_get (model, a,
450 COLUMN_ID, &lang_id_1,
451 COLUMN_LANGUAGE, &lang_name_1,
452 -1);
453 gtk_tree_model_get (model, b,
454 COLUMN_ID, &lang_id_2,
455 COLUMN_LANGUAGE, &lang_name_2,
456 -1);
457 if (lang_id_1 == 0 || lang_id_2 == 0) {
458 /* sort All before any other */
459 ret = (gint)lang_id_1 - (gint)lang_id_2;
460 } else {
461 /* probably no need for a better string sorting function */
462 ret = g_ascii_strcasecmp (lang_name_1, lang_name_2);
463 }
464 g_free (lang_name_1);
465 g_free (lang_name_2);
466
467 return ret;
468 }
469
470
471 /*----------------------------- Begin public API -----------------------------*/
472
473 GtkWidget *
474 ggd_doctype_selector_new (void)
475 {
476 return g_object_new (GGD_TYPE_DOCTYPE_SELECTOR, NULL);
477 }
478
479 gboolean
480 ggd_doctype_selector_set_doctype (GgdDoctypeSelector *self,
481 guint language_id,
482 const gchar *doctype)
483 {
484 g_return_val_if_fail (GGD_IS_DOCTYPE_SELECTOR (self), FALSE);
485 g_return_val_if_fail (language_id >= 0 &&
486 language_id < GEANY_MAX_BUILT_IN_FILETYPES,
487 FALSE);
488
489 return update_doctype (self, language_id, doctype);
490 }
491
492 gchar *
493 ggd_doctype_selector_get_doctype (GgdDoctypeSelector *self,
494 guint language_id)
495 {
496 gchar *doctype = NULL;
497
498 g_return_val_if_fail (GGD_IS_DOCTYPE_SELECTOR (self), FALSE);
499 g_return_val_if_fail (language_id >= 0 &&
500 language_id < GEANY_MAX_BUILT_IN_FILETYPES,
501 FALSE);
502
503 get_row_value (self, language_id, COLUMN_DOCTYPE, &doctype);
504
505 return doctype;
506 }