c898cfd7ea03a5bdad913c7a49239c64381bfba0
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 <string.h>
46 #include <gdk/gdkkeysyms.h>
47 #include <gtk/gtktoolitem.h>
48 #include <gtk/gtkspinbutton.h>
49 #include <gtk/gtkhbox.h>
50 #include <gtk/gtklabel.h>
51 #include <gtk/gtkmisc.h>
52 #include <gtk/gtktoolbar.h>
53 #include <gtk/gtktooltips.h>
54 #include <gtk/gtkradiomenuitem.h>
56 #include "ege-adjustment-action.h"
59 static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass );
60 static void ege_adjustment_action_init( EgeAdjustmentAction* action );
61 static void ege_adjustment_action_finalize( GObject* object );
62 static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
63 static void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
65 static GtkWidget* create_menu_item( GtkAction* action );
66 static GtkWidget* create_tool_item( GtkAction* action );
67 static void connect_proxy( GtkAction *action, GtkWidget *proxy );
68 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy );
70 static gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
71 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
72 static gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
74 static void ege_adjustment_action_defocus( EgeAdjustmentAction* action );
76 static void egeAct_free_description( gpointer data, gpointer user_data );
77 static void egeAct_free_all_descriptions( EgeAdjustmentAction* action );
80 static GtkActionClass* gParentClass = 0;
81 static GQuark gDataName = 0;
83 typedef struct _EgeAdjustmentDescr EgeAdjustmentDescr;
85 struct _EgeAdjustmentDescr
86 {
87 gchar* descr;
88 gdouble value;
89 };
91 struct _EgeAdjustmentActionPrivate
92 {
93 GtkAdjustment* adj;
94 GtkTooltips* toolTips;
95 GtkWidget* focusWidget;
96 gdouble climbRate;
97 guint digits;
98 gdouble epsilon;
99 gchar* format;
100 gchar* selfId;
101 EgeWidgetFixup toolPost;
102 gdouble lastVal;
103 gdouble step;
104 gdouble page;
105 gboolean transferFocus;
106 GList* descriptions;
107 };
109 #define EGE_ADJUSTMENT_ACTION_GET_PRIVATE( o ) ( G_TYPE_INSTANCE_GET_PRIVATE( (o), EGE_ADJUSTMENT_ACTION_TYPE, EgeAdjustmentActionPrivate ) )
111 enum {
112 PROP_ADJUSTMENT = 1,
113 PROP_FOCUS_WIDGET,
114 PROP_CLIMB_RATE,
115 PROP_DIGITS,
116 PROP_SELFID,
117 PROP_TOOL_POST
118 };
120 enum {
121 BUMP_TOP = 0,
122 BUMP_PAGE_UP,
123 BUMP_UP,
124 BUMP_NONE,
125 BUMP_DOWN,
126 BUMP_PAGE_DOWN,
127 BUMP_BOTTOM,
128 BUMP_CUSTOM = 100
129 };
131 GType ege_adjustment_action_get_type( void )
132 {
133 static GType myType = 0;
134 if ( !myType ) {
135 static const GTypeInfo myInfo = {
136 sizeof( EgeAdjustmentActionClass ),
137 NULL, /* base_init */
138 NULL, /* base_finalize */
139 (GClassInitFunc)ege_adjustment_action_class_init,
140 NULL, /* class_finalize */
141 NULL, /* class_data */
142 sizeof( EgeAdjustmentAction ),
143 0, /* n_preallocs */
144 (GInstanceInitFunc)ege_adjustment_action_init,
145 NULL
146 };
148 myType = g_type_register_static( GTK_TYPE_ACTION, "EgeAdjustmentAction", &myInfo, (GTypeFlags)0 );
149 }
151 return myType;
152 }
155 static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass )
156 {
157 if ( klass ) {
158 gParentClass = GTK_ACTION_CLASS( g_type_class_peek_parent( klass ) );
159 GObjectClass * objClass = G_OBJECT_CLASS( klass );
161 gDataName = g_quark_from_string("ege-adj-action");
163 objClass->finalize = ege_adjustment_action_finalize;
165 objClass->get_property = ege_adjustment_action_get_property;
166 objClass->set_property = ege_adjustment_action_set_property;
168 klass->parent_class.create_menu_item = create_menu_item;
169 klass->parent_class.create_tool_item = create_tool_item;
170 klass->parent_class.connect_proxy = connect_proxy;
171 klass->parent_class.disconnect_proxy = disconnect_proxy;
173 g_object_class_install_property( objClass,
174 PROP_ADJUSTMENT,
175 g_param_spec_object( "adjustment",
176 "Adjustment",
177 "The adjustment to change",
178 GTK_TYPE_ADJUSTMENT,
179 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
181 g_object_class_install_property( objClass,
182 PROP_FOCUS_WIDGET,
183 g_param_spec_pointer( "focus-widget",
184 "Focus Widget",
185 "The widget to return focus to",
186 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
188 g_object_class_install_property( objClass,
189 PROP_CLIMB_RATE,
190 g_param_spec_double( "climb-rate",
191 "Climb Rate",
192 "The acelleraton rate",
193 0.0, G_MAXDOUBLE, 0.0,
194 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
196 g_object_class_install_property( objClass,
197 PROP_DIGITS,
198 g_param_spec_uint( "digits",
199 "Digits",
200 "The number of digits to show",
201 0, 20, 0,
202 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
204 g_object_class_install_property( objClass,
205 PROP_SELFID,
206 g_param_spec_string( "self-id",
207 "Self ID",
208 "Marker for self pointer",
209 0,
210 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
212 g_object_class_install_property( objClass,
213 PROP_TOOL_POST,
214 g_param_spec_pointer( "tool-post",
215 "Tool Widget post process",
216 "Function for final adjustments",
217 (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
219 g_type_class_add_private( klass, sizeof(EgeAdjustmentActionClass) );
220 }
221 }
223 static void ege_adjustment_action_init( EgeAdjustmentAction* action )
224 {
225 action->private_data = EGE_ADJUSTMENT_ACTION_GET_PRIVATE( action );
226 action->private_data->adj = 0;
227 action->private_data->toolTips = 0;
228 action->private_data->focusWidget = 0;
229 action->private_data->climbRate = 0.0;
230 action->private_data->digits = 2;
231 action->private_data->epsilon = 0.009;
232 action->private_data->format = g_strdup_printf("%%0.%df%%s%%s", action->private_data->digits);
233 action->private_data->selfId = 0;
234 action->private_data->toolPost = 0;
235 action->private_data->lastVal = 0.0;
236 action->private_data->step = 0.0;
237 action->private_data->page = 0.0;
238 action->private_data->transferFocus = FALSE;
239 action->private_data->descriptions = 0;
240 }
242 static void ege_adjustment_action_finalize( GObject* object )
243 {
244 EgeAdjustmentAction* action = 0;
245 g_return_if_fail( object != NULL );
246 g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(object) );
248 action = EGE_ADJUSTMENT_ACTION( object );
250 if ( action->private_data->format ) {
251 g_free( action->private_data->format );
252 action->private_data->format = 0;
253 }
255 egeAct_free_all_descriptions( action );
257 if ( G_OBJECT_CLASS(gParentClass)->finalize ) {
258 (*G_OBJECT_CLASS(gParentClass)->finalize)(object);
259 }
260 }
262 EgeAdjustmentAction* ege_adjustment_action_new( GtkAdjustment* adjustment,
263 const gchar *name,
264 const gchar *label,
265 const gchar *tooltip,
266 const gchar *stock_id,
267 gdouble climb_rate,
268 guint digits )
269 {
270 GObject* obj = (GObject*)g_object_new( EGE_ADJUSTMENT_ACTION_TYPE,
271 "name", name,
272 "label", label,
273 "tooltip", tooltip,
274 "stock_id", stock_id,
275 "adjustment", adjustment,
276 "climb-rate", climb_rate,
277 "digits", digits,
278 NULL );
280 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
282 return action;
283 }
285 static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
286 {
287 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
288 switch ( propId ) {
289 case PROP_ADJUSTMENT:
290 g_value_set_object( value, action->private_data->adj );
291 break;
293 case PROP_FOCUS_WIDGET:
294 g_value_set_pointer( value, action->private_data->focusWidget );
295 break;
297 case PROP_CLIMB_RATE:
298 g_value_set_double( value, action->private_data->climbRate );
299 break;
301 case PROP_DIGITS:
302 g_value_set_uint( value, action->private_data->digits );
303 break;
305 case PROP_SELFID:
306 g_value_set_string( value, action->private_data->selfId );
307 break;
309 case PROP_TOOL_POST:
310 g_value_set_pointer( value, (void*)action->private_data->toolPost );
311 break;
313 default:
314 G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
315 }
316 }
318 void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
319 {
320 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
321 switch ( propId ) {
322 case PROP_ADJUSTMENT:
323 {
324 action->private_data->adj = GTK_ADJUSTMENT( g_value_get_object( value ) );
325 g_object_get( G_OBJECT(action->private_data->adj),
326 "step-increment", &action->private_data->step,
327 "page-increment", &action->private_data->page,
328 NULL );
329 }
330 break;
332 case PROP_FOCUS_WIDGET:
333 {
334 /* TODO unhook prior */
335 action->private_data->focusWidget = (GtkWidget*)g_value_get_pointer( value );
336 }
337 break;
339 case PROP_CLIMB_RATE:
340 {
341 /* TODO pass on */
342 action->private_data->climbRate = g_value_get_double( value );
343 }
344 break;
346 case PROP_DIGITS:
347 {
348 /* TODO pass on */
349 action->private_data->digits = g_value_get_uint( value );
350 switch ( action->private_data->digits ) {
351 case 0: action->private_data->epsilon = 0.9; break;
352 case 1: action->private_data->epsilon = 0.09; break;
353 case 2: action->private_data->epsilon = 0.009; break;
354 case 3: action->private_data->epsilon = 0.0009; break;
355 case 4: action->private_data->epsilon = 0.00009; break;
356 }
357 if ( action->private_data->format ) {
358 g_free( action->private_data->format );
359 }
360 action->private_data->format = g_strdup_printf("%%0.%df%%s%%s", action->private_data->digits);
361 }
362 break;
364 case PROP_SELFID:
365 {
366 /* TODO pass on */
367 gchar* prior = action->private_data->selfId;
368 action->private_data->selfId = g_value_dup_string( value );
369 g_free( prior );
370 }
371 break;
373 case PROP_TOOL_POST:
374 {
375 action->private_data->toolPost = (EgeWidgetFixup)g_value_get_pointer( value );
376 }
377 break;
379 default:
380 G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
381 }
382 }
384 GtkAdjustment* ege_adjustment_action_get_adjustment( EgeAdjustmentAction* action )
385 {
386 g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
388 return action->private_data->adj;
389 }
391 void ege_adjustment_action_set_focuswidget( EgeAdjustmentAction* action, GtkWidget* widget )
392 {
393 g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
395 /* TODO unhook prior */
397 action->private_data->focusWidget = widget;
398 }
400 GtkWidget* ege_adjustment_action_get_focuswidget( EgeAdjustmentAction* action )
401 {
402 g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
404 return action->private_data->focusWidget;
405 }
407 static void egeAct_free_description( gpointer data, gpointer user_data ) {
408 (void)user_data;
409 if ( data ) {
410 EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)data;
411 if ( descr->descr ) {
412 g_free( descr->descr );
413 descr->descr = 0;
414 }
415 g_free( descr );
416 }
417 }
419 static void egeAct_free_all_descriptions( EgeAdjustmentAction* action )
420 {
421 if ( action->private_data->descriptions ) {
422 g_list_foreach( action->private_data->descriptions, egeAct_free_description, 0 );
423 g_list_free( action->private_data->descriptions );
424 action->private_data->descriptions = 0;
425 }
426 }
428 static gint egeAct_compare_descriptions( gconstpointer a, gconstpointer b )
429 {
430 gint val = 0;
432 EgeAdjustmentDescr const * aa = (EgeAdjustmentDescr const *)a;
433 EgeAdjustmentDescr const * bb = (EgeAdjustmentDescr const *)b;
435 if ( aa && bb ) {
436 if ( aa->value < bb->value ) {
437 val = -1;
438 } else if ( aa->value > bb->value ) {
439 val = 1;
440 }
441 }
443 return val;
444 }
446 void ege_adjustment_action_set_descriptions( EgeAdjustmentAction* action, gchar const** descriptions, gdouble const* values, guint count )
447 {
448 g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
450 egeAct_free_all_descriptions( action );
452 if ( count && descriptions && values ) {
453 guint i = 0;
454 for ( i = 0; i < count; i++ ) {
455 EgeAdjustmentDescr* descr = g_new0( EgeAdjustmentDescr, 1 );
456 descr->descr = descriptions[i] ? g_strdup( descriptions[i] ) : 0;
457 descr->value = values[i];
458 action->private_data->descriptions = g_list_insert_sorted( action->private_data->descriptions, (gpointer)descr, egeAct_compare_descriptions );
459 }
460 }
461 }
463 static void process_menu_action( GtkWidget* obj, gpointer data )
464 {
465 GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(obj);
466 if ( item->active ) {
467 EgeAdjustmentAction* act = (EgeAdjustmentAction*)g_object_get_qdata( G_OBJECT(obj), gDataName );
468 gint what = GPOINTER_TO_INT(data);
471 gdouble base = gtk_adjustment_get_value( act->private_data->adj );
472 gdouble lower = 0.0;
473 gdouble upper = 0.0;
474 gdouble step = 0.0;
475 gdouble page = 0.0;
476 g_object_get( G_OBJECT(act->private_data->adj),
477 "lower", &lower,
478 "upper", &upper,
479 "step-increment", &step,
480 "page-increment", &page,
481 NULL );
483 switch ( what ) {
484 case BUMP_TOP:
485 gtk_adjustment_set_value( act->private_data->adj, upper );
486 break;
488 case BUMP_PAGE_UP:
489 gtk_adjustment_set_value( act->private_data->adj, base + page );
490 break;
492 case BUMP_UP:
493 gtk_adjustment_set_value( act->private_data->adj, base + step );
494 break;
496 case BUMP_DOWN:
497 gtk_adjustment_set_value( act->private_data->adj, base - step );
498 break;
500 case BUMP_PAGE_DOWN:
501 gtk_adjustment_set_value( act->private_data->adj, base - page );
502 break;
504 case BUMP_BOTTOM:
505 gtk_adjustment_set_value( act->private_data->adj, lower );
506 break;
508 default:
509 if ( what >= BUMP_CUSTOM ) {
510 guint index = what - BUMP_CUSTOM;
511 if ( index < g_list_length( act->private_data->descriptions ) ) {
512 EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)g_list_nth_data( act->private_data->descriptions, index );
513 if ( descr ) {
514 gtk_adjustment_set_value( act->private_data->adj, descr->value );
515 }
516 }
517 }
518 }
519 }
520 }
522 static void create_single_menu_item( GCallback toggleCb, int val, GtkWidget* menu, EgeAdjustmentAction* act, GtkWidget** dst, GSList** group, gdouble num, gboolean active )
523 {
524 char* str = 0;
525 EgeAdjustmentDescr* marker = 0;
526 GList* cur = act->private_data->descriptions;
528 while ( cur ) {
529 EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
530 gdouble delta = num - descr->value;
531 if ( delta < 0.0 ) {
532 delta = -delta;
533 }
534 if ( delta < act->private_data->epsilon ) {
535 marker = descr;
536 break;
537 }
538 cur = g_list_next( cur );
539 }
541 str = g_strdup_printf( act->private_data->format, num, (marker?" ":""), ( (marker && marker->descr) ? marker->descr:"") );
543 *dst = gtk_radio_menu_item_new_with_label( *group, str );
544 if ( !*group) {
545 *group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(*dst) );
546 }
547 if ( active ) {
548 gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(*dst), TRUE );
549 }
550 gtk_menu_shell_append( GTK_MENU_SHELL(menu), *dst );
551 g_object_set_qdata( G_OBJECT(*dst), gDataName, act );
553 g_signal_connect( G_OBJECT(*dst), "toggled", toggleCb, GINT_TO_POINTER(val) );
555 g_free(str);
556 }
558 static GList* flush_explicit_items( GList* descriptions,
559 GCallback toggleCb,
560 int val,
561 GtkWidget* menu,
562 EgeAdjustmentAction* act,
563 GtkWidget** dst,
564 GSList** group,
565 gdouble num )
566 {
567 GList* cur = descriptions;
569 if ( cur ) {
570 gdouble valUpper = num + act->private_data->epsilon;
571 gdouble valLower = num - act->private_data->epsilon;
573 EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
575 while ( cur && descr && (descr->value >= valLower) ) {
576 if ( descr->value > valUpper ) {
577 create_single_menu_item( toggleCb, val + g_list_position(act->private_data->descriptions, cur), menu, act, dst, group, descr->value, FALSE );
578 }
580 cur = g_list_previous( cur );
581 descr = cur ? (EgeAdjustmentDescr*)cur->data : 0;
582 }
583 }
585 return cur;
586 }
588 static GtkWidget* create_popup_number_menu( EgeAdjustmentAction* act )
589 {
590 GtkWidget* menu = gtk_menu_new();
592 GSList* group = 0;
593 GtkWidget* single = 0;
595 GList* addOns = g_list_last( act->private_data->descriptions );
597 gdouble base = gtk_adjustment_get_value( act->private_data->adj );
598 gdouble lower = 0.0;
599 gdouble upper = 0.0;
600 gdouble step = 0.0;
601 gdouble page = 0.0;
602 g_object_get( G_OBJECT(act->private_data->adj),
603 "lower", &lower,
604 "upper", &upper,
605 "step-increment", &step,
606 "page-increment", &page,
607 NULL );
610 if ( base < upper ) {
611 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, upper );
612 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_TOP, menu, act, &single, &group, upper, FALSE );
613 if ( (base + page) < upper ) {
614 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + page );
615 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_UP, menu, act, &single, &group, base + page, FALSE );
616 }
617 if ( (base + step) < upper ) {
618 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + step );
619 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_UP, menu, act, &single, &group, base + step, FALSE );
620 }
621 }
623 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base );
624 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_NONE, menu, act, &single, &group, base, TRUE );
626 if ( base > lower ) {
627 if ( (base - step) > lower ) {
628 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - step );
629 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_DOWN, menu, act, &single, &group, base - step, FALSE );
630 }
631 if ( (base - page) > lower ) {
632 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - page );
633 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_DOWN, menu, act, &single, &group, base - page, FALSE );
634 }
635 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, lower );
636 create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_BOTTOM, menu, act, &single, &group, lower, FALSE );
637 }
639 if ( act->private_data->descriptions ) {
640 gdouble value = ((EgeAdjustmentDescr*)act->private_data->descriptions->data)->value;
641 addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, value );
642 }
644 return menu;
645 }
647 static GtkWidget* create_menu_item( GtkAction* action )
648 {
649 GtkWidget* item = 0;
651 if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
652 EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
653 GValue value;
654 const gchar* sss = 0;
655 GtkWidget* subby = 0;
657 memset( &value, 0, sizeof(value) );
658 g_value_init( &value, G_TYPE_STRING );
659 g_object_get_property( G_OBJECT(action), "label", &value );
661 sss = g_value_get_string( &value );
663 item = gtk_menu_item_new_with_label( sss );
665 subby = create_popup_number_menu( act );
666 gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), subby );
667 gtk_widget_show_all( subby );
668 } else {
669 item = gParentClass->create_menu_item( action );
670 }
672 return item;
673 }
675 void value_changed_cb( GtkSpinButton* spin, EgeAdjustmentAction* act )
676 {
677 if ( GTK_WIDGET_HAS_FOCUS( GTK_WIDGET(spin) ) ) {
678 ege_adjustment_action_defocus( act );
679 }
680 }
682 static gboolean event_cb( EgeAdjustmentAction* act, GdkEvent* evt )
683 {
684 gboolean handled = FALSE;
685 if ( evt->type == GDK_BUTTON_PRESS ) {
686 if ( evt->button.button == 3 ) {
687 if ( IS_EGE_ADJUSTMENT_ACTION(act) ) {
688 GdkEventButton* btnevt = (GdkEventButton*)evt;
689 GtkWidget* menu = create_popup_number_menu(act);
690 gtk_widget_show_all( menu );
691 gtk_menu_popup( GTK_MENU(menu), NULL, NULL, NULL, NULL, btnevt->button, btnevt->time );
692 }
693 handled = TRUE;
694 }
695 }
697 return handled;
698 }
700 static GtkWidget* create_tool_item( GtkAction* action )
701 {
702 GtkWidget* item = 0;
704 if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
705 EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
706 GtkWidget* spinbutton = gtk_spin_button_new( act->private_data->adj, act->private_data->climbRate, act->private_data->digits );
707 GtkWidget* hb = gtk_hbox_new( FALSE, 5 );
708 GValue value;
710 item = GTK_WIDGET( gtk_tool_item_new() );
712 memset( &value, 0, sizeof(value) );
713 g_value_init( &value, G_TYPE_STRING );
714 g_object_get_property( G_OBJECT(action), "label", &value );
715 const gchar* sss = g_value_get_string( &value );
716 GtkWidget* lbl = gtk_label_new( sss ? sss : "wwww" );
718 {
719 GValue tooltip;
720 memset( &tooltip, 0, sizeof(tooltip) );
721 g_value_init( &tooltip, G_TYPE_STRING );
722 g_object_get_property( G_OBJECT(action), "tooltip", &tooltip );
723 const gchar* tipstr = g_value_get_string( &tooltip );
724 if ( tipstr && *tipstr ) {
725 if ( !act->private_data->toolTips ) {
726 act->private_data->toolTips = gtk_tooltips_new();
727 }
728 gtk_tooltips_set_tip( act->private_data->toolTips, spinbutton, tipstr, 0 );
729 }
730 }
732 gtk_misc_set_alignment( GTK_MISC(lbl), 1.0, 0.5 );
734 gtk_box_pack_start( GTK_BOX(hb), lbl, FALSE, FALSE, 0 );
735 gtk_box_pack_end( GTK_BOX(hb), spinbutton, FALSE, FALSE, 0 );
736 gtk_container_add( GTK_CONTAINER(item), hb );
738 if ( act->private_data->selfId ) {
739 g_object_set_data( G_OBJECT(spinbutton), act->private_data->selfId, spinbutton );
740 }
742 g_signal_connect( G_OBJECT(spinbutton), "focus-in-event", G_CALLBACK(focus_in_cb), action );
743 g_signal_connect( G_OBJECT(spinbutton), "focus-out-event", G_CALLBACK(focus_out_cb), action );
744 g_signal_connect( G_OBJECT(spinbutton), "key-press-event", G_CALLBACK(keypress_cb), action );
746 g_signal_connect( G_OBJECT(spinbutton), "value-changed", G_CALLBACK(value_changed_cb), action );
748 g_signal_connect_swapped( G_OBJECT(spinbutton), "event", G_CALLBACK(event_cb), action );
750 gtk_widget_show_all( item );
752 /* Shrink or whatnot after shown */
753 if ( act->private_data->toolPost ) {
754 act->private_data->toolPost( item );
755 }
756 } else {
757 item = gParentClass->create_tool_item( action );
758 }
760 return item;
761 }
763 static void connect_proxy( GtkAction *action, GtkWidget *proxy )
764 {
765 gParentClass->connect_proxy( action, proxy );
766 }
768 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy )
769 {
770 gParentClass->disconnect_proxy( action, proxy );
771 }
773 void ege_adjustment_action_defocus( EgeAdjustmentAction* action )
774 {
775 if ( action->private_data->transferFocus ) {
776 if ( action->private_data->focusWidget ) {
777 gtk_widget_grab_focus( action->private_data->focusWidget );
778 }
779 }
780 }
782 gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
783 {
784 (void)event;
785 if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
786 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
787 action->private_data->lastVal = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
788 action->private_data->transferFocus = TRUE;
789 }
791 return FALSE; /* report event not consumed */
792 }
794 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
795 {
796 (void)widget;
797 (void)event;
798 if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
799 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
800 action->private_data->transferFocus = FALSE;
801 }
803 return FALSE; /* report event not consumed */
804 }
807 static gboolean process_tab( GtkWidget* widget, int direction )
808 {
809 gboolean handled = FALSE;
810 GtkWidget* parent = gtk_widget_get_parent(widget);
811 GtkWidget* gp = parent ? gtk_widget_get_parent(parent) : 0;
812 GtkWidget* ggp = gp ? gtk_widget_get_parent(gp) : 0;
814 if ( ggp && GTK_IS_TOOLBAR(ggp) ) {
815 GList* kids = gtk_container_get_children( GTK_CONTAINER(ggp) );
816 if ( kids ) {
817 GtkWidget* curr = widget;
818 while ( curr && (gtk_widget_get_parent(curr) != ggp) ) {
819 curr = gtk_widget_get_parent( curr );
820 }
821 if ( curr ) {
822 GList* mid = g_list_find( kids, curr );
823 while ( mid ) {
824 mid = ( direction < 0 ) ? g_list_previous(mid) : g_list_next(mid);
825 if ( mid && GTK_IS_TOOL_ITEM(mid->data) ) {
826 /* potential target */
827 GtkWidget* child = gtk_bin_get_child( GTK_BIN(mid->data) );
828 if ( child && GTK_IS_HBOX(child) ) { /* could be ours */
829 GList* subChildren = gtk_container_get_children( GTK_CONTAINER(child) );
830 if ( subChildren ) {
831 GList* last = g_list_last(subChildren);
832 if ( last && GTK_IS_SPIN_BUTTON(last->data) && GTK_WIDGET_IS_SENSITIVE( GTK_WIDGET(last->data) ) ) {
833 gtk_widget_grab_focus( GTK_WIDGET(last->data) );
834 handled = TRUE;
835 mid = 0; /* to stop loop */
836 }
838 g_list_free(subChildren);
839 }
840 }
841 }
842 }
843 }
844 g_list_free( kids );
845 }
846 }
848 return handled;
849 }
851 gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
852 {
853 gboolean wasConsumed = FALSE; /* default to report event not consumed */
854 EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION(data);
855 guint key = 0;
856 gdk_keymap_translate_keyboard_state( gdk_keymap_get_for_display( gdk_display_get_default() ),
857 event->hardware_keycode, (GdkModifierType)event->state,
858 0, &key, 0, 0, 0 );
860 switch ( key ) {
861 case GDK_Escape:
862 {
863 action->private_data->transferFocus = TRUE;
864 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
865 ege_adjustment_action_defocus( action );
866 wasConsumed = TRUE;
867 }
868 break;
870 case GDK_Return:
871 case GDK_KP_Enter:
872 {
873 action->private_data->transferFocus = TRUE;
874 ege_adjustment_action_defocus( action );
875 wasConsumed = TRUE;
876 }
877 break;
879 case GDK_Tab:
880 {
881 action->private_data->transferFocus = FALSE;
882 wasConsumed = process_tab( widget, 1 );
883 }
884 break;
886 case GDK_ISO_Left_Tab:
887 {
888 action->private_data->transferFocus = FALSE;
889 wasConsumed = process_tab( widget, -1 );
890 }
891 break;
893 case GDK_Up:
894 case GDK_KP_Up:
895 {
896 action->private_data->transferFocus = FALSE;
897 gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
898 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->step );
899 wasConsumed = TRUE;
900 }
901 break;
903 case GDK_Down:
904 case GDK_KP_Down:
905 {
906 action->private_data->transferFocus = FALSE;
907 gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
908 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->step );
909 wasConsumed = TRUE;
910 }
911 break;
913 case GDK_Page_Up:
914 case GDK_KP_Page_Up:
915 {
916 action->private_data->transferFocus = FALSE;
917 gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
918 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->page );
919 wasConsumed = TRUE;
920 }
921 break;
923 case GDK_Page_Down:
924 case GDK_KP_Page_Down:
925 {
926 action->private_data->transferFocus = FALSE;
927 gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
928 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->page );
929 wasConsumed = TRUE;
930 }
931 break;
933 case GDK_z:
934 case GDK_Z:
935 {
936 action->private_data->transferFocus = FALSE;
937 gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
938 wasConsumed = TRUE;
939 }
940 break;
942 }
944 return wasConsumed;
945 }