3 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
4 *
5 */
6 /* ***** BEGIN LICENSE BLOCK *****
7 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
8 *
9 * The contents of this file are subject to the Mozilla Public License Version
10 * 1.1 (the "License"); you may not use this file except in compliance with
11 * the License. You may obtain a copy of the License at
12 * http://www.mozilla.org/MPL/
13 *
14 * Software distributed under the License is distributed on an "AS IS" basis,
15 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
16 * for the specific language governing rights and limitations under the
17 * License.
18 *
19 * The Original Code is EGE Adjustment Action.
20 *
21 * The Initial Developer of the Original Code is
22 * Jon A. Cruz.
23 * Portions created by the Initial Developer are Copyright (C) 2006
24 * the Initial Developer. All Rights Reserved.
25 *
26 * Contributor(s):
27 *
28 * Alternatively, the contents of this file may be used under the terms of
29 * either the GNU General Public License Version 2 or later (the "GPL"), or
30 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
31 * in which case the provisions of the GPL or the LGPL are applicable instead
32 * of those above. If you wish to allow use of your version of this file only
33 * under the terms of either the GPL or the LGPL, and not to allow others to
34 * use your version of this file under the terms of the MPL, indicate your
35 * decision by deleting the provisions above and replace them with the notice
36 * and other provisions required by the GPL or the LGPL. If you do not delete
37 * the provisions above, a recipient may use your version of this file under
38 * the terms of any one of the MPL, the GPL or the LGPL.
39 *
40 * ***** END LICENSE BLOCK ***** */
42 /* Note: this file should be kept compilable as both .cpp and .c */
44 #include <cmath>
45 #include <string.h>
47 #include <gdk/gdkkeysyms.h>
48 #include <gtk/gtkversion.h>
49 #include <gtk/gtktoolitem.h>
50 #include <gtk/gtk.h>
51 #include <gtk/gtkhscale.h>
52 #if GTK_CHECK_VERSION(2,12,0)
53 #include <gtk/gtkscalebutton.h>
54 #include <gtk/gtkstock.h>
55 #endif /* GTK_CHECK_VERSION(2,12,0) */
56 #include <gtk/gtkhbox.h>
57 #include <gtk/gtklabel.h>
58 #include <gtk/gtkmisc.h>
59 #include <gtk/gtktoolbar.h>
60 #include <gtk/gtktooltips.h>
61 #include <gtk/gtkradiomenuitem.h>
63 #include "widgets/icon.h"
64 #include "icon-size.h"
65 #include "ege-adjustment-action.h"
68 static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass );
69 static void ege_adjustment_action_init( EgeAdjustmentAction* action );
70 static void ege_adjustment_action_finalize( GObject* object );
71 static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
72 static void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
74 static GtkWidget* create_menu_item( GtkAction* action );
75 static GtkWidget* create_tool_item( GtkAction* action );
76 static void connect_proxy( GtkAction *action, GtkWidget *proxy );
77 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy );
79 static gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
80 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
81 static gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
83 static void ege_adjustment_action_defocus( EgeAdjustmentAction* action );
85 static void egeAct_free_description( gpointer data, gpointer user_data );
86 static void egeAct_free_all_descriptions( EgeAdjustmentAction* action );
89 static GtkActionClass* gParentClass = 0;
90 static GQuark gDataName = 0;
92 enum {
93 APPEARANCE_UNKNOWN = -1,
94 APPEARANCE_NONE = 0,
95 APPEARANCE_FULL, // label, then all choices represented by separate buttons
96 APPEARANCE_COMPACT, // label, then choices in a drop-down menu
97 APPEARANCE_MINIMAL, // no label, just choices in a drop-down menu
98 };
100 #if GTK_CHECK_VERSION(2,12,0)
101 /* TODO need to have appropriate icons setup for these: */
102 static const gchar *floogles[] = {
103 GTK_STOCK_REMOVE,
104 GTK_STOCK_ADD,
105 GTK_STOCK_GO_DOWN,
106 GTK_STOCK_ABOUT,
107 GTK_STOCK_GO_UP,
108 0};
109 #endif /* GTK_CHECK_VERSION(2,12,0) */
111 typedef struct _EgeAdjustmentDescr EgeAdjustmentDescr;
113 struct _EgeAdjustmentDescr
114 {
115 gchar* descr;
116 gdouble value;
117 };
119 struct _EgeAdjustmentActionPrivate
120 {
121 GtkAdjustment* adj;
122 GtkTooltips* toolTips;
123 GtkWidget* focusWidget;
124 gdouble climbRate;
125 guint digits;
126 gdouble epsilon;
127 gchar* format;
128 gchar* selfId;
129 EgeWidgetFixup toolPost;
130 gdouble lastVal;
131 gdouble step;
132 gdouble page;
133 gint appearanceMode;
134 gboolean transferFocus;
135 GList* descriptions;
136 gchar* appearance;
137 gchar* iconId;
138 Inkscape::IconSize iconSize;
139 };
141 #define EGE_ADJUSTMENT_ACTION_GET_PRIVATE( o ) ( G_TYPE_INSTANCE_GET_PRIVATE( (o), EGE_ADJUSTMENT_ACTION_TYPE, EgeAdjustmentActionPrivate ) )
143 enum {
144 PROP_ADJUSTMENT = 1,
145 PROP_FOCUS_WIDGET,
146 PROP_CLIMB_RATE,
147 PROP_DIGITS,
148 PROP_SELFID,
149 PROP_TOOL_POST,
150 PROP_APPEARANCE,
151 PROP_ICON_ID,
152 PROP_ICON_SIZE
153 };
155 enum {
156 BUMP_TOP = 0,
157 BUMP_PAGE_UP,
158 BUMP_UP,
159 BUMP_NONE,
160 BUMP_DOWN,
161 BUMP_PAGE_DOWN,
162 BUMP_BOTTOM,
163 BUMP_CUSTOM = 100
164 };
166 GType ege_adjustment_action_get_type( void )
167 {
168 static GType myType = 0;
169 if ( !myType ) {
170 static const GTypeInfo myInfo = {
171 sizeof( EgeAdjustmentActionClass ),
172 NULL, /* base_init */
173 NULL, /* base_finalize */
174 (GClassInitFunc)ege_adjustment_action_class_init,
175 NULL, /* class_finalize */
176 NULL, /* class_data */
177 sizeof( EgeAdjustmentAction ),
178 0, /* n_preallocs */
179 (GInstanceInitFunc)ege_adjustment_action_init,
180 NULL
181 };
183 myType = g_type_register_static( GTK_TYPE_ACTION, "EgeAdjustmentAction", &myInfo, (GTypeFlags)0 );
184 }
186 return myType;
187 }
190 static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass )
191 {
192 if ( klass ) {
193 gParentClass = GTK_ACTION_CLASS( g_type_class_peek_parent( klass ) );
194 GObjectClass * objClass = G_OBJECT_CLASS( klass );
196 gDataName = g_quark_from_string("ege-adj-action");
198 objClass->finalize = ege_adjustment_action_finalize;
200 objClass->get_property = ege_adjustment_action_get_property;
201 objClass->set_property = ege_adjustment_action_set_property;
203 klass->parent_class.create_menu_item = create_menu_item;
204 klass->parent_class.create_tool_item = create_tool_item;
205 klass->parent_class.connect_proxy = connect_proxy;
206 klass->parent_class.disconnect_proxy = disconnect_proxy;
208 g_object_class_install_property( objClass,
209 PROP_ADJUSTMENT,
210 g_param_spec_object( "adjustment",
211 "Adjustment",
212 "The adjustment to change",
213 GTK_TYPE_ADJUSTMENT,
214 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
216 g_object_class_install_property( objClass,
217 PROP_FOCUS_WIDGET,
218 g_param_spec_pointer( "focus-widget",
219 "Focus Widget",
220 "The widget to return focus to",
221 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
223 g_object_class_install_property( objClass,
224 PROP_CLIMB_RATE,
225 g_param_spec_double( "climb-rate",
226 "Climb Rate",
227 "The acelleraton rate",
228 0.0, G_MAXDOUBLE, 0.0,
229 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
231 g_object_class_install_property( objClass,
232 PROP_DIGITS,
233 g_param_spec_uint( "digits",
234 "Digits",
235 "The number of digits to show",
236 0, 20, 0,
237 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
239 g_object_class_install_property( objClass,
240 PROP_SELFID,
241 g_param_spec_string( "self-id",
242 "Self ID",
243 "Marker for self pointer",
244 0,
245 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
247 g_object_class_install_property( objClass,
248 PROP_TOOL_POST,
249 g_param_spec_pointer( "tool-post",
250 "Tool Widget post process",
251 "Function for final adjustments",
252 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
254 g_object_class_install_property( objClass,
255 PROP_APPEARANCE,
256 g_param_spec_string( "appearance",
257 "Appearance hint",
258 "A hint for how to display",
259 "",
260 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
262 g_object_class_install_property( objClass,
263 PROP_ICON_ID,
264 g_param_spec_string( "iconId",
265 "Icon ID",
266 "The id for the icon",
267 "",
268 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
270 g_object_class_install_property( objClass,
271 PROP_ICON_SIZE,
272 g_param_spec_int( "iconSize",
273 "Icon Size",
274 "The size the icon",
275 (int)Inkscape::ICON_SIZE_MENU,
276 (int)Inkscape::ICON_SIZE_DECORATION,
277 (int)Inkscape::ICON_SIZE_SMALL_TOOLBAR,
278 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
280 g_type_class_add_private( klass, sizeof(EgeAdjustmentActionClass) );
281 }
282 }
284 static void ege_adjustment_action_init( EgeAdjustmentAction* action )
285 {
286 action->private_data = EGE_ADJUSTMENT_ACTION_GET_PRIVATE( action );
287 action->private_data->adj = 0;
288 action->private_data->toolTips = 0;
289 action->private_data->focusWidget = 0;
290 action->private_data->climbRate = 0.0;
291 action->private_data->digits = 2;
292 action->private_data->epsilon = 0.009;
293 action->private_data->format = g_strdup_printf("%%0.%df%%s%%s", action->private_data->digits);
294 action->private_data->selfId = 0;
295 action->private_data->toolPost = 0;
296 action->private_data->lastVal = 0.0;
297 action->private_data->step = 0.0;
298 action->private_data->page = 0.0;
299 action->private_data->appearanceMode = APPEARANCE_NONE;
300 action->private_data->transferFocus = FALSE;
301 action->private_data->descriptions = 0;
302 action->private_data->appearance = 0;
303 action->private_data->iconId = 0;
304 action->private_data->iconSize = Inkscape::ICON_SIZE_SMALL_TOOLBAR;
305 }
307 static void ege_adjustment_action_finalize( GObject* object )
308 {
309 EgeAdjustmentAction* action = 0;
310 g_return_if_fail( object != NULL );
311 g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(object) );
313 action = EGE_ADJUSTMENT_ACTION( object );
315 if ( action->private_data->format ) {
316 g_free( action->private_data->format );
317 action->private_data->format = 0;
318 }
320 egeAct_free_all_descriptions( action );
322 if ( G_OBJECT_CLASS(gParentClass)->finalize ) {
323 (*G_OBJECT_CLASS(gParentClass)->finalize)(object);
324 }
325 }
327 EgeAdjustmentAction* ege_adjustment_action_new( GtkAdjustment* adjustment,
328 const gchar *name,
329 const gchar *label,
330 const gchar *tooltip,
331 const gchar *stock_id,
332 gdouble climb_rate,
333 guint digits )
334 {
335 GObject* obj = (GObject*)g_object_new( EGE_ADJUSTMENT_ACTION_TYPE,
336 "name", name,
337 "label", label,
338 "tooltip", tooltip,
339 "stock_id", stock_id,
340 "adjustment", adjustment,
341 "climb-rate", climb_rate,
342 "digits", digits,
343 NULL );
345 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
347 return action;
348 }
350 static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
351 {
352 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
353 switch ( propId ) {
354 case PROP_ADJUSTMENT:
355 g_value_set_object( value, action->private_data->adj );
356 break;
358 case PROP_FOCUS_WIDGET:
359 g_value_set_pointer( value, action->private_data->focusWidget );
360 break;
362 case PROP_CLIMB_RATE:
363 g_value_set_double( value, action->private_data->climbRate );
364 break;
366 case PROP_DIGITS:
367 g_value_set_uint( value, action->private_data->digits );
368 break;
370 case PROP_SELFID:
371 g_value_set_string( value, action->private_data->selfId );
372 break;
374 case PROP_TOOL_POST:
375 g_value_set_pointer( value, (void*)action->private_data->toolPost );
376 break;
378 case PROP_APPEARANCE:
379 g_value_set_string( value, action->private_data->appearance );
380 break;
382 case PROP_ICON_ID:
383 g_value_set_string( value, action->private_data->iconId );
384 break;
386 case PROP_ICON_SIZE:
387 g_value_set_int( value, action->private_data->iconSize );
388 break;
390 default:
391 G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
392 }
393 }
395 void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
396 {
397 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
398 switch ( propId ) {
399 case PROP_ADJUSTMENT:
400 {
401 action->private_data->adj = GTK_ADJUSTMENT( g_value_get_object( value ) );
402 g_object_get( G_OBJECT(action->private_data->adj),
403 "step-increment", &action->private_data->step,
404 "page-increment", &action->private_data->page,
405 NULL );
406 }
407 break;
409 case PROP_FOCUS_WIDGET:
410 {
411 /* TODO unhook prior */
412 action->private_data->focusWidget = (GtkWidget*)g_value_get_pointer( value );
413 }
414 break;
416 case PROP_CLIMB_RATE:
417 {
418 /* TODO pass on */
419 action->private_data->climbRate = g_value_get_double( value );
420 }
421 break;
423 case PROP_DIGITS:
424 {
425 /* TODO pass on */
426 action->private_data->digits = g_value_get_uint( value );
427 switch ( action->private_data->digits ) {
428 case 0: action->private_data->epsilon = 0.9; break;
429 case 1: action->private_data->epsilon = 0.09; break;
430 case 2: action->private_data->epsilon = 0.009; break;
431 case 3: action->private_data->epsilon = 0.0009; break;
432 case 4: action->private_data->epsilon = 0.00009; break;
433 }
434 if ( action->private_data->format ) {
435 g_free( action->private_data->format );
436 }
437 action->private_data->format = g_strdup_printf("%%0.%df%%s%%s", action->private_data->digits);
438 }
439 break;
441 case PROP_SELFID:
442 {
443 /* TODO pass on */
444 gchar* prior = action->private_data->selfId;
445 action->private_data->selfId = g_value_dup_string( value );
446 g_free( prior );
447 }
448 break;
450 case PROP_TOOL_POST:
451 {
452 action->private_data->toolPost = (EgeWidgetFixup)g_value_get_pointer( value );
453 }
454 break;
456 case PROP_APPEARANCE:
457 {
458 gchar* tmp = action->private_data->appearance;
459 gchar* newVal = g_value_dup_string( value );
460 action->private_data->appearance = newVal;
461 g_free( tmp );
463 if ( !action->private_data->appearance || (strcmp("", newVal) == 0) ) {
464 action->private_data->appearanceMode = APPEARANCE_NONE;
465 } else if ( strcmp("full", newVal) == 0 ) {
466 action->private_data->appearanceMode = APPEARANCE_FULL;
467 } else if ( strcmp("compact", newVal) == 0 ) {
468 action->private_data->appearanceMode = APPEARANCE_COMPACT;
469 } else if ( strcmp("minimal", newVal) == 0 ) {
470 action->private_data->appearanceMode = APPEARANCE_MINIMAL;
471 } else {
472 action->private_data->appearanceMode = APPEARANCE_UNKNOWN;
473 }
474 }
475 break;
477 case PROP_ICON_ID:
478 {
479 gchar* tmp = action->private_data->iconId;
480 action->private_data->iconId = g_value_dup_string( value );
481 g_free( tmp );
482 }
483 break;
485 case PROP_ICON_SIZE:
486 {
487 action->private_data->iconSize = (Inkscape::IconSize)g_value_get_int( value );
488 }
489 break;
491 default:
492 G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
493 }
494 }
496 GtkAdjustment* ege_adjustment_action_get_adjustment( EgeAdjustmentAction* action )
497 {
498 g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
500 return action->private_data->adj;
501 }
503 void ege_adjustment_action_set_focuswidget( EgeAdjustmentAction* action, GtkWidget* widget )
504 {
505 g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
507 /* TODO unhook prior */
509 action->private_data->focusWidget = widget;
510 }
512 GtkWidget* ege_adjustment_action_get_focuswidget( EgeAdjustmentAction* action )
513 {
514 g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
516 return action->private_data->focusWidget;
517 }
519 static void egeAct_free_description( gpointer data, gpointer user_data ) {
520 (void)user_data;
521 if ( data ) {
522 EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)data;
523 if ( descr->descr ) {
524 g_free( descr->descr );
525 descr->descr = 0;
526 }
527 g_free( descr );
528 }
529 }
531 static void egeAct_free_all_descriptions( EgeAdjustmentAction* action )
532 {
533 if ( action->private_data->descriptions ) {
534 g_list_foreach( action->private_data->descriptions, egeAct_free_description, 0 );
535 g_list_free( action->private_data->descriptions );
536 action->private_data->descriptions = 0;
537 }
538 }
540 static gint egeAct_compare_descriptions( gconstpointer a, gconstpointer b )
541 {
542 gint val = 0;
544 EgeAdjustmentDescr const * aa = (EgeAdjustmentDescr const *)a;
545 EgeAdjustmentDescr const * bb = (EgeAdjustmentDescr const *)b;
547 if ( aa && bb ) {
548 if ( aa->value < bb->value ) {
549 val = -1;
550 } else if ( aa->value > bb->value ) {
551 val = 1;
552 }
553 }
555 return val;
556 }
558 void ege_adjustment_action_set_descriptions( EgeAdjustmentAction* action, gchar const** descriptions, gdouble const* values, guint count )
559 {
560 g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
562 egeAct_free_all_descriptions( action );
564 if ( count && descriptions && values ) {
565 guint i = 0;
566 for ( i = 0; i < count; i++ ) {
567 EgeAdjustmentDescr* descr = g_new0( EgeAdjustmentDescr, 1 );
568 descr->descr = descriptions[i] ? g_strdup( descriptions[i] ) : 0;
569 descr->value = values[i];
570 action->private_data->descriptions = g_list_insert_sorted( action->private_data->descriptions, (gpointer)descr, egeAct_compare_descriptions );
571 }
572 }
573 }
575 void ege_adjustment_action_set_appearance( EgeAdjustmentAction* action, gchar const* val )
576 {
577 g_object_set( G_OBJECT(action), "appearance", val, NULL );
578 }
580 static void process_menu_action( GtkWidget* obj, gpointer data )
581 {
582 GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(obj);
583 if ( item->active ) {
584 EgeAdjustmentAction* act = (EgeAdjustmentAction*)g_object_get_qdata( G_OBJECT(obj), gDataName );
585 gint what = GPOINTER_TO_INT(data);
588 gdouble base = gtk_adjustment_get_value( act->private_data->adj );
589 gdouble lower = 0.0;
590 gdouble upper = 0.0;
591 gdouble step = 0.0;
592 gdouble page = 0.0;
593 g_object_get( G_OBJECT(act->private_data->adj),
594 "lower", &lower,
595 "upper", &upper,
596 "step-increment", &step,
597 "page-increment", &page,
598 NULL );
600 switch ( what ) {
601 case BUMP_TOP:
602 gtk_adjustment_set_value( act->private_data->adj, upper );
603 break;
605 case BUMP_PAGE_UP:
606 gtk_adjustment_set_value( act->private_data->adj, base + page );
607 break;
609 case BUMP_UP:
610 gtk_adjustment_set_value( act->private_data->adj, base + step );
611 break;
613 case BUMP_DOWN:
614 gtk_adjustment_set_value( act->private_data->adj, base - step );
615 break;
617 case BUMP_PAGE_DOWN:
618 gtk_adjustment_set_value( act->private_data->adj, base - page );
619 break;
621 case BUMP_BOTTOM:
622 gtk_adjustment_set_value( act->private_data->adj, lower );
623 break;
625 default:
626 if ( what >= BUMP_CUSTOM ) {
627 guint index = what - BUMP_CUSTOM;
628 if ( index < g_list_length( act->private_data->descriptions ) ) {
629 EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)g_list_nth_data( act->private_data->descriptions, index );
630 if ( descr ) {
631 gtk_adjustment_set_value( act->private_data->adj, descr->value );
632 }
633 }
634 }
635 }
636 }
637 }
639 static void create_single_menu_item( GCallback toggleCb, int val, GtkWidget* menu, EgeAdjustmentAction* act, GtkWidget** dst, GSList** group, gdouble num, gboolean active )
640 {
641 char* str = 0;
642 EgeAdjustmentDescr* marker = 0;
643 GList* cur = act->private_data->descriptions;
645 while ( cur ) {
646 EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
647 gdouble delta = num - descr->value;
648 if ( delta < 0.0 ) {
649 delta = -delta;
650 }
651 if ( delta < act->private_data->epsilon ) {
652 marker = descr;
653 break;
654 }
655 cur = g_list_next( cur );
656 }
658 str = g_strdup_printf( act->private_data->format, num,
659 ((marker && marker->descr) ? ": " : ""),
660 ((marker && marker->descr) ? marker->descr : ""));
662 *dst = gtk_radio_menu_item_new_with_label( *group, str );
663 if ( !*group) {
664 *group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(*dst) );
665 }
666 if ( active ) {
667 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(*dst), TRUE );
668 }
669 gtk_menu_shell_append( GTK_MENU_SHELL(menu), *dst );
670 g_object_set_qdata( G_OBJECT(*dst), gDataName, act );
672 g_signal_connect( G_OBJECT(*dst), "toggled", toggleCb, GINT_TO_POINTER(val) );
674 g_free(str);
675 }
677 static GList* flush_explicit_items( GList* descriptions,
678 GCallback toggleCb,
679 int val,
680 GtkWidget* menu,
681 EgeAdjustmentAction* act,
682 GtkWidget** dst,
683 GSList** group,
684 gdouble num )
685 {
686 GList* cur = descriptions;
688 if ( cur ) {
689 gdouble valUpper = num + act->private_data->epsilon;
690 gdouble valLower = num - act->private_data->epsilon;
692 EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
694 while ( cur && descr && (descr->value >= valLower) ) {
695 if ( descr->value > valUpper ) {
696 create_single_menu_item( toggleCb, val + g_list_position(act->private_data->descriptions, cur), menu, act, dst, group, descr->value, FALSE );
697 }
699 cur = g_list_previous( cur );
700 descr = cur ? (EgeAdjustmentDescr*)cur->data : 0;
701 }
702 }
704 return cur;
705 }
707 static GtkWidget* create_popup_number_menu( EgeAdjustmentAction* act )
708 {
709 GtkWidget* menu = gtk_menu_new();
711 GSList* group = 0;
712 GtkWidget* single = 0;
714 GList* addOns = g_list_last( act->private_data->descriptions );
716 gdouble base = gtk_adjustment_get_value( act->private_data->adj );
717 gdouble lower = 0.0;
718 gdouble upper = 0.0;
719 gdouble step = 0.0;
720 gdouble page = 0.0;
721 g_object_get( G_OBJECT(act->private_data->adj),
722 "lower", &lower,
723 "upper", &upper,
724 "step-increment", &step,
725 "page-increment", &page,
726 NULL );
729 if ( base < upper ) {
730 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, upper );
731 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_TOP, menu, act, &single, &group, upper, FALSE );
732 if ( (base + page) < upper ) {
733 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + page );
734 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_UP, menu, act, &single, &group, base + page, FALSE );
735 }
736 if ( (base + step) < upper ) {
737 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + step );
738 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_UP, menu, act, &single, &group, base + step, FALSE );
739 }
740 }
742 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base );
743 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_NONE, menu, act, &single, &group, base, TRUE );
745 if ( base > lower ) {
746 if ( (base - step) > lower ) {
747 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - step );
748 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_DOWN, menu, act, &single, &group, base - step, FALSE );
749 }
750 if ( (base - page) > lower ) {
751 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - page );
752 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_DOWN, menu, act, &single, &group, base - page, FALSE );
753 }
754 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, lower );
755 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_BOTTOM, menu, act, &single, &group, lower, FALSE );
756 }
758 if ( act->private_data->descriptions ) {
759 gdouble value = ((EgeAdjustmentDescr*)act->private_data->descriptions->data)->value;
760 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, value );
761 }
763 return menu;
764 }
766 static GtkWidget* create_menu_item( GtkAction* action )
767 {
768 GtkWidget* item = 0;
770 if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
771 EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
772 GValue value;
773 const gchar* sss = 0;
774 GtkWidget* subby = 0;
776 memset( &value, 0, sizeof(value) );
777 g_value_init( &value, G_TYPE_STRING );
778 g_object_get_property( G_OBJECT(action), "label", &value );
780 sss = g_value_get_string( &value );
782 item = gtk_menu_item_new_with_label( sss );
784 subby = create_popup_number_menu( act );
785 gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), subby );
786 gtk_widget_show_all( subby );
787 } else {
788 item = gParentClass->create_menu_item( action );
789 }
791 return item;
792 }
794 void value_changed_cb( GtkSpinButton* spin, EgeAdjustmentAction* act )
795 {
796 if ( GTK_WIDGET_HAS_FOCUS( GTK_WIDGET(spin) ) ) {
797 ege_adjustment_action_defocus( act );
798 }
799 }
801 static gboolean event_cb( EgeAdjustmentAction* act, GdkEvent* evt )
802 {
803 gboolean handled = FALSE;
804 if ( evt->type == GDK_BUTTON_PRESS ) {
805 if ( evt->button.button == 3 ) {
806 if ( IS_EGE_ADJUSTMENT_ACTION(act) ) {
807 GdkEventButton* btnevt = (GdkEventButton*)evt;
808 GtkWidget* menu = create_popup_number_menu(act);
809 gtk_widget_show_all( menu );
810 gtk_menu_popup( GTK_MENU(menu), NULL, NULL, NULL, NULL, btnevt->button, btnevt->time );
811 }
812 handled = TRUE;
813 }
814 }
816 return handled;
817 }
819 static gchar*
820 slider_format_falue (GtkScale* scale, gdouble value, gchar *label)
821 {
822 (void)scale;
823 return g_strdup_printf("%s %d", label, (int) round(value));
824 }
826 static GtkWidget* create_tool_item( GtkAction* action )
827 {
828 GtkWidget* item = 0;
830 if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
831 EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
832 GtkWidget* spinbutton = 0;
833 GtkWidget* hb = gtk_hbox_new( FALSE, 5 );
835 GValue value;
836 memset( &value, 0, sizeof(value) );
837 g_value_init( &value, G_TYPE_STRING );
838 g_object_get_property( G_OBJECT(action), "short_label", &value );
839 const gchar* sss = g_value_get_string( &value );
841 if ( act->private_data->appearanceMode == APPEARANCE_FULL ) {
842 // Slider
843 spinbutton = gtk_hscale_new( act->private_data->adj);
844 gtk_widget_set_size_request(spinbutton, 100, -1);
845 gtk_scale_set_digits (GTK_SCALE(spinbutton), 0);
846 gtk_signal_connect(GTK_OBJECT(spinbutton), "format-value", GTK_SIGNAL_FUNC(slider_format_falue), (void *) sss);
848 #if GTK_CHECK_VERSION(2,12,0)
849 } else if ( act->private_data->appearanceMode == APPEARANCE_MINIMAL ) {
850 spinbutton = gtk_scale_button_new( GTK_ICON_SIZE_MENU, 0, 100, 2, 0 );
851 gtk_scale_button_set_adjustment( GTK_SCALE_BUTTON(spinbutton), act->private_data->adj );
852 gtk_scale_button_set_icons( GTK_SCALE_BUTTON(spinbutton), floogles );
853 #endif /* GTK_CHECK_VERSION(2,12,0) */
854 } else {
855 spinbutton = gtk_spin_button_new( act->private_data->adj, act->private_data->climbRate, act->private_data->digits );
856 }
858 item = GTK_WIDGET( gtk_tool_item_new() );
860 {
861 GValue tooltip;
862 memset( &tooltip, 0, sizeof(tooltip) );
863 g_value_init( &tooltip, G_TYPE_STRING );
864 g_object_get_property( G_OBJECT(action), "tooltip", &tooltip );
865 const gchar* tipstr = g_value_get_string( &tooltip );
866 if ( tipstr && *tipstr ) {
867 if ( !act->private_data->toolTips ) {
868 act->private_data->toolTips = gtk_tooltips_new();
869 }
870 gtk_tooltips_set_tip( act->private_data->toolTips, spinbutton, tipstr, 0 );
871 }
872 }
874 if ( act->private_data->appearanceMode != APPEARANCE_FULL ) {
875 GtkWidget* filler1 = gtk_label_new(" ");
876 gtk_box_pack_start( GTK_BOX(hb), filler1, FALSE, FALSE, 0 );
878 // Use an icon if available or use short-label
879 if ( act->private_data->iconId && strcmp( act->private_data->iconId, "" ) != 0 ) {
880 GtkWidget* icon = sp_icon_new( act->private_data->iconSize, act->private_data->iconId );
881 gtk_box_pack_start( GTK_BOX(hb), icon, FALSE, FALSE, 0 );
882 } else {
883 GtkWidget* lbl = gtk_label_new( sss ? sss : "wwww" );
884 gtk_misc_set_alignment( GTK_MISC(lbl), 1.0, 0.5 );
885 gtk_box_pack_start( GTK_BOX(hb), lbl, FALSE, FALSE, 0 );
886 }
887 }
889 if ( act->private_data->appearanceMode == APPEARANCE_FULL ) {
890 gtk_box_pack_start( GTK_BOX(hb), spinbutton, TRUE, TRUE, 0 );
891 } else {
892 gtk_box_pack_start( GTK_BOX(hb), spinbutton, FALSE, FALSE, 0 );
893 }
895 gtk_container_add( GTK_CONTAINER(item), hb );
897 if ( act->private_data->selfId ) {
898 g_object_set_data( G_OBJECT(spinbutton), act->private_data->selfId, spinbutton );
899 }
901 g_signal_connect( G_OBJECT(spinbutton), "focus-in-event", G_CALLBACK(focus_in_cb), action );
902 g_signal_connect( G_OBJECT(spinbutton), "focus-out-event", G_CALLBACK(focus_out_cb), action );
903 g_signal_connect( G_OBJECT(spinbutton), "key-press-event", G_CALLBACK(keypress_cb), action );
905 g_signal_connect( G_OBJECT(spinbutton), "value-changed", G_CALLBACK(value_changed_cb), action );
907 g_signal_connect_swapped( G_OBJECT(spinbutton), "event", G_CALLBACK(event_cb), action );
908 if ( act->private_data->appearanceMode == APPEARANCE_FULL ) {
909 /* */
910 #if GTK_CHECK_VERSION(2,12,0)
911 } else if ( act->private_data->appearanceMode == APPEARANCE_MINIMAL ) {
912 /* */
913 #endif /* GTK_CHECK_VERSION(2,12,0) */
914 } else {
915 gtk_entry_set_width_chars( GTK_ENTRY(spinbutton), act->private_data->digits + 3 );
916 }
918 gtk_widget_show_all( item );
920 /* Shrink or whatnot after shown */
921 if ( act->private_data->toolPost ) {
922 act->private_data->toolPost( item );
923 }
924 } else {
925 item = gParentClass->create_tool_item( action );
926 }
928 return item;
929 }
931 static void connect_proxy( GtkAction *action, GtkWidget *proxy )
932 {
933 gParentClass->connect_proxy( action, proxy );
934 }
936 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy )
937 {
938 gParentClass->disconnect_proxy( action, proxy );
939 }
941 void ege_adjustment_action_defocus( EgeAdjustmentAction* action )
942 {
943 if ( action->private_data->transferFocus ) {
944 if ( action->private_data->focusWidget ) {
945 gtk_widget_grab_focus( action->private_data->focusWidget );
946 }
947 }
948 }
950 gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
951 {
952 (void)event;
953 if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
954 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
955 if ( GTK_IS_SPIN_BUTTON(widget) ) {
956 action->private_data->lastVal = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
957 #if GTK_CHECK_VERSION(2,12,0)
958 } else if ( GTK_IS_SCALE_BUTTON(widget) ) {
959 action->private_data->lastVal = gtk_scale_button_get_value( GTK_SCALE_BUTTON(widget) );
960 #endif /* GTK_CHECK_VERSION(2,12,0) */
961 } else if (GTK_IS_RANGE(widget) ) {
962 action->private_data->lastVal = gtk_range_get_value( GTK_RANGE(widget) );
963 }
964 action->private_data->transferFocus = TRUE;
965 }
967 return FALSE; /* report event not consumed */
968 }
970 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
971 {
972 (void)widget;
973 (void)event;
974 if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
975 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
976 action->private_data->transferFocus = FALSE;
977 }
979 return FALSE; /* report event not consumed */
980 }
983 static gboolean process_tab( GtkWidget* widget, int direction )
984 {
985 gboolean handled = FALSE;
986 GtkWidget* parent = gtk_widget_get_parent(widget);
987 GtkWidget* gp = parent ? gtk_widget_get_parent(parent) : 0;
988 GtkWidget* ggp = gp ? gtk_widget_get_parent(gp) : 0;
990 if ( ggp && GTK_IS_TOOLBAR(ggp) ) {
991 GList* kids = gtk_container_get_children( GTK_CONTAINER(ggp) );
992 if ( kids ) {
993 GtkWidget* curr = widget;
994 while ( curr && (gtk_widget_get_parent(curr) != ggp) ) {
995 curr = gtk_widget_get_parent( curr );
996 }
997 if ( curr ) {
998 GList* mid = g_list_find( kids, curr );
999 while ( mid ) {
1000 mid = ( direction < 0 ) ? g_list_previous(mid) : g_list_next(mid);
1001 if ( mid && GTK_IS_TOOL_ITEM(mid->data) ) {
1002 /* potential target */
1003 GtkWidget* child = gtk_bin_get_child( GTK_BIN(mid->data) );
1004 if ( child && GTK_IS_HBOX(child) ) { /* could be ours */
1005 GList* subChildren = gtk_container_get_children( GTK_CONTAINER(child) );
1006 if ( subChildren ) {
1007 GList* last = g_list_last(subChildren);
1008 if ( last && GTK_IS_SPIN_BUTTON(last->data) && GTK_WIDGET_IS_SENSITIVE( GTK_WIDGET(last->data) ) ) {
1009 gtk_widget_grab_focus( GTK_WIDGET(last->data) );
1010 handled = TRUE;
1011 mid = 0; /* to stop loop */
1012 }
1014 g_list_free(subChildren);
1015 }
1016 }
1017 }
1018 }
1019 }
1020 g_list_free( kids );
1021 }
1022 }
1024 return handled;
1025 }
1027 gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
1028 {
1029 gboolean wasConsumed = FALSE; /* default to report event not consumed */
1030 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION(data);
1031 guint key = 0;
1032 gdk_keymap_translate_keyboard_state( gdk_keymap_get_for_display( gdk_display_get_default() ),
1033 event->hardware_keycode, (GdkModifierType)event->state,
1034 0, &key, 0, 0, 0 );
1036 switch ( key ) {
1037 case GDK_Escape:
1038 {
1039 action->private_data->transferFocus = TRUE;
1040 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
1041 ege_adjustment_action_defocus( action );
1042 wasConsumed = TRUE;
1043 }
1044 break;
1046 case GDK_Return:
1047 case GDK_KP_Enter:
1048 {
1049 action->private_data->transferFocus = TRUE;
1050 ege_adjustment_action_defocus( action );
1051 wasConsumed = TRUE;
1052 }
1053 break;
1055 case GDK_Tab:
1056 {
1057 action->private_data->transferFocus = FALSE;
1058 wasConsumed = process_tab( widget, 1 );
1059 }
1060 break;
1062 case GDK_ISO_Left_Tab:
1063 {
1064 action->private_data->transferFocus = FALSE;
1065 wasConsumed = process_tab( widget, -1 );
1066 }
1067 break;
1069 case GDK_Up:
1070 case GDK_KP_Up:
1071 {
1072 action->private_data->transferFocus = FALSE;
1073 gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
1074 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->step );
1075 wasConsumed = TRUE;
1076 }
1077 break;
1079 case GDK_Down:
1080 case GDK_KP_Down:
1081 {
1082 action->private_data->transferFocus = FALSE;
1083 gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
1084 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->step );
1085 wasConsumed = TRUE;
1086 }
1087 break;
1089 case GDK_Page_Up:
1090 case GDK_KP_Page_Up:
1091 {
1092 action->private_data->transferFocus = FALSE;
1093 gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
1094 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->page );
1095 wasConsumed = TRUE;
1096 }
1097 break;
1099 case GDK_Page_Down:
1100 case GDK_KP_Page_Down:
1101 {
1102 action->private_data->transferFocus = FALSE;
1103 gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
1104 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->page );
1105 wasConsumed = TRUE;
1106 }
1107 break;
1109 case GDK_z:
1110 case GDK_Z:
1111 {
1112 action->private_data->transferFocus = FALSE;
1113 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
1114 wasConsumed = TRUE;
1115 }
1116 break;
1118 }
1120 return wasConsumed;
1121 }