1 #define __SP_COLOR_NOTEBOOK_C__
3 /*
4 * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages
5 *
6 * Author:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * bulia byak <buliabyak@users.sf.net>
9 *
10 * Copyright (C) 2001-2002 Lauris Kaplinski
11 *
12 * This code is in public domain
13 */
15 #undef SPCS_PREVIEW
16 #define noDUMP_CHANGE_INFO
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
22 #include <cstring>
23 #include <string>
24 #include <cstdlib>
25 #include <gtk/gtk.h>
26 #include <glibmm/i18n.h>
28 #include "../dialogs/dialog-events.h"
29 #include "../preferences.h"
30 #include "sp-color-notebook.h"
31 #include "spw-utilities.h"
32 #include "sp-color-scales.h"
33 #include "sp-color-icc-selector.h"
34 #include "sp-color-wheel-selector.h"
35 #include "svg/svg-icc-color.h"
36 #include "../inkscape.h"
37 #include "../document.h"
38 #include "../profile-manager.h"
40 struct SPColorNotebookTracker {
41 const gchar* name;
42 const gchar* className;
43 GType type;
44 guint submode;
45 gboolean enabledFull;
46 gboolean enabledBrief;
47 SPColorNotebook *backPointer;
48 };
50 static void sp_color_notebook_class_init (SPColorNotebookClass *klass);
51 static void sp_color_notebook_init (SPColorNotebook *colorbook);
52 static void sp_color_notebook_destroy (GtkObject *object);
54 static void sp_color_notebook_show_all (GtkWidget *widget);
55 static void sp_color_notebook_hide_all (GtkWidget *widget);
57 static SPColorSelectorClass *parent_class;
59 #define XPAD 4
60 #define YPAD 1
62 GType sp_color_notebook_get_type(void)
63 {
64 static GtkType type = 0;
65 if (!type) {
66 GTypeInfo info = {
67 sizeof(SPColorNotebookClass),
68 0, // base_init
69 0, // base_finalize
70 (GClassInitFunc)sp_color_notebook_class_init,
71 0, // class_finalize
72 0, // class_data
73 sizeof(SPColorNotebook),
74 0, // n_preallocs
75 (GInstanceInitFunc)sp_color_notebook_init,
76 0 // value_table
77 };
78 type = g_type_register_static(SP_TYPE_COLOR_SELECTOR, "SPColorNotebook", &info, static_cast<GTypeFlags>(0));
79 }
80 return type;
81 }
83 static void
84 sp_color_notebook_class_init (SPColorNotebookClass *klass)
85 {
86 GtkObjectClass *object_class;
87 GtkWidgetClass *widget_class;
88 SPColorSelectorClass *selector_class;
90 object_class = (GtkObjectClass *) klass;
91 widget_class = (GtkWidgetClass *) klass;
92 selector_class = SP_COLOR_SELECTOR_CLASS (klass);
94 parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
96 object_class->destroy = sp_color_notebook_destroy;
98 widget_class->show_all = sp_color_notebook_show_all;
99 widget_class->hide_all = sp_color_notebook_hide_all;
100 }
102 static void
103 sp_color_notebook_switch_page(GtkNotebook *notebook,
104 GtkNotebookPage *page,
105 guint page_num,
106 SPColorNotebook *colorbook)
107 {
108 if ( colorbook )
109 {
110 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
111 nb->switchPage( notebook, page, page_num );
113 // remember the page we seitched to
114 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
115 prefs->setInt("/colorselector/page", page_num);
116 }
117 }
119 void ColorNotebook::switchPage(GtkNotebook*,
120 GtkNotebookPage*,
121 guint page_num)
122 {
123 SPColorSelector* csel;
124 GtkWidget* widget;
126 if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) >= 0 )
127 {
128 csel = getCurrentSelector();
129 csel->base->getColorAlpha(_color, &_alpha);
130 }
131 widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), page_num);
132 if ( widget && SP_IS_COLOR_SELECTOR (widget) )
133 {
134 csel = SP_COLOR_SELECTOR (widget);
135 csel->base->setColorAlpha( _color, _alpha );
137 // Temporary workaround to undo a spurious GRABBED
138 _released();
139 }
140 }
142 static gint sp_color_notebook_menu_handler( GtkWidget *widget, GdkEvent *event )
143 {
144 if (event->type == GDK_BUTTON_PRESS)
145 {
146 SPColorSelector* csel = SP_COLOR_SELECTOR(widget);
147 ((ColorNotebook*)(csel->base))->menuHandler( event );
149 /* Tell calling code that we have handled this event; the buck
150 * stops here. */
151 return TRUE;
152 }
154 /* Tell calling code that we have not handled this event; pass it on. */
155 return FALSE;
156 }
158 gint ColorNotebook::menuHandler( GdkEvent* event )
159 {
160 GdkEventButton *bevent = (GdkEventButton *) event;
161 gtk_menu_popup (GTK_MENU( _popup ), NULL, NULL, NULL, NULL,
162 bevent->button, bevent->time);
163 return TRUE;
164 }
166 static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data)
167 {
168 gboolean active = FALSE;
170 active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
171 SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data);
172 if ( entry )
173 {
174 if ( active )
175 {
176 ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode);
177 }
178 else
179 {
180 ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode);
181 }
182 }
183 }
185 static void
186 sp_color_notebook_init (SPColorNotebook *colorbook)
187 {
188 SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) );
190 if ( SP_COLOR_SELECTOR(colorbook)->base )
191 {
192 SP_COLOR_SELECTOR(colorbook)->base->init();
193 }
194 }
196 void ColorNotebook::init()
197 {
198 GtkWidget* table = 0;
199 guint row = 0;
200 guint i = 0;
201 guint j = 0;
202 GType *selector_types = 0;
203 guint selector_type_count = 0;
205 GtkTooltips *tt = gtk_tooltips_new ();
207 /* tempory hardcoding to get types loaded */
208 SP_TYPE_COLOR_SCALES;
209 SP_TYPE_COLOR_WHEEL_SELECTOR;
210 #if ENABLE_LCMS
211 SP_TYPE_COLOR_ICC_SELECTOR;
212 #endif // ENABLE_LCMS
214 /* REJON: Comment out the next line to not use the normal GTK Color
215 wheel. */
217 // SP_TYPE_COLOR_GTKSELECTOR;
219 _updating = FALSE;
220 _updatingrgba = FALSE;
221 _btn = 0;
222 _popup = 0;
223 _trackerList = g_ptr_array_new ();
225 _book = gtk_notebook_new ();
226 gtk_widget_show (_book);
228 selector_types = g_type_children (SP_TYPE_COLOR_SELECTOR, &selector_type_count);
230 for ( i = 0; i < selector_type_count; i++ )
231 {
232 if (!g_type_is_a (selector_types[i], SP_TYPE_COLOR_NOTEBOOK))
233 {
234 guint howmany = 1;
235 gpointer klass = gtk_type_class (selector_types[i]);
236 if ( klass && SP_IS_COLOR_SELECTOR_CLASS (klass) )
237 {
238 SPColorSelectorClass *ck = SP_COLOR_SELECTOR_CLASS (klass);
239 howmany = MAX (1, ck->submode_count);
240 for ( j = 0; j < howmany; j++ )
241 {
242 SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (malloc(sizeof(SPColorNotebookTracker)));
243 if ( entry )
244 {
245 memset( entry, 0, sizeof(SPColorNotebookTracker) );
246 entry->name = ck->name[j];
247 entry->type = selector_types[i];
248 entry->submode = j;
249 entry->enabledFull = TRUE;
250 entry->enabledBrief = TRUE;
251 entry->backPointer = SP_COLOR_NOTEBOOK(_csel);
253 g_ptr_array_add (_trackerList, entry);
254 }
255 }
256 }
257 }
258 }
260 for ( i = 0; i < _trackerList->len; i++ )
261 {
262 SPColorNotebookTracker *entry =
263 reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
264 if ( entry )
265 {
266 addPage(entry->type, entry->submode);
267 }
268 }
270 table = gtk_table_new (2, 3, FALSE);
271 gtk_widget_show (table);
273 gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
275 gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1,
276 static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
277 static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
278 XPAD, YPAD);
280 // restore the last active page
281 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
282 gtk_notebook_set_current_page (GTK_NOTEBOOK (_book), prefs->getInt("/colorselector/page", 0));
284 {
285 gboolean found = FALSE;
287 _popup = gtk_menu_new();
288 GtkMenu *menu = GTK_MENU (_popup);
290 for ( i = 0; i < _trackerList->len; i++ )
291 {
292 SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
293 if ( entry )
294 {
295 GtkWidget *item = gtk_check_menu_item_new_with_label (_(entry->name));
296 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), entry->enabledFull);
297 gtk_widget_show (item);
298 gtk_menu_append (menu, item);
300 g_signal_connect (G_OBJECT (item), "activate",
301 G_CALLBACK (sp_color_notebook_menuitem_response),
302 reinterpret_cast< gpointer > (entry) );
303 found = TRUE;
304 }
305 }
307 GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
308 gtk_widget_show (arrow);
310 _btn = gtk_button_new ();
311 gtk_widget_show (_btn);
312 gtk_container_add (GTK_CONTAINER (_btn), arrow);
314 GtkWidget *align = gtk_alignment_new (1.0, 0.0, 0.0, 0.0);
315 gtk_widget_show (align);
316 gtk_container_add (GTK_CONTAINER (align), _btn);
318 // uncomment to reenable the "show/hide modes" menu,
319 // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!)
320 //gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
322 gtk_signal_connect_object(GTK_OBJECT(_btn), "event", GTK_SIGNAL_FUNC (sp_color_notebook_menu_handler), GTK_OBJECT(_csel));
323 if ( !found )
324 {
325 gtk_widget_set_sensitive (_btn, FALSE);
326 }
327 }
329 row++;
331 GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
333 #if ENABLE_LCMS
334 /* Create color management icons */
335 _box_colormanaged = gtk_event_box_new ();
336 GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
337 gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged);
338 GtkTooltips *tooltips_colormanaged = gtk_tooltips_new ();
339 gtk_tooltips_set_tip (tooltips_colormanaged, _box_colormanaged, _("Color Managed"), "");
340 gtk_widget_set_sensitive (_box_colormanaged, false);
341 gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, FALSE, FALSE, 2);
343 _box_outofgamut = gtk_event_box_new ();
344 GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
345 gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut);
346 GtkTooltips *tooltips_outofgamut = gtk_tooltips_new ();
347 gtk_tooltips_set_tip (tooltips_outofgamut, _box_outofgamut, _("Out of gamut!"), "");
348 gtk_widget_set_sensitive (_box_outofgamut, false);
349 gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, FALSE, FALSE, 2);
351 _box_toomuchink = gtk_event_box_new ();
352 GtkWidget *toomuchink = gtk_image_new_from_icon_name ("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
353 gtk_container_add (GTK_CONTAINER (_box_toomuchink), toomuchink);
354 GtkTooltips *tooltips_toomuchink = gtk_tooltips_new ();
355 gtk_tooltips_set_tip (tooltips_toomuchink, _box_toomuchink, _("Too much ink!"), "");
356 gtk_widget_set_sensitive (_box_toomuchink, false);
357 gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2);
359 #endif //ENABLE_LCMS
361 /* Create RGBA entry and color preview */
362 _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
363 gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
364 gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
366 _rgbae = gtk_entry_new ();
367 sp_dialog_defocus_on_enter (_rgbae);
368 gtk_entry_set_max_length (GTK_ENTRY (_rgbae), 8);
369 gtk_entry_set_width_chars (GTK_ENTRY (_rgbae), 8);
370 gtk_tooltips_set_tip (tt, _rgbae, _("Hexadecimal RGBA value of the color"), NULL);
371 gtk_box_pack_start(GTK_BOX(rgbabox), _rgbae, FALSE, FALSE, 0);
372 gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), _rgbae);
374 sp_set_font_size_smaller (rgbabox);
375 gtk_widget_show_all (rgbabox);
377 #if ENABLE_LCMS
378 //the "too much ink" icon is initially hidden
379 gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
380 #endif //ENABLE_LCMS
382 gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
384 #ifdef SPCS_PREVIEW
385 _p = sp_color_preview_new (0xffffffff);
386 gtk_widget_show (_p);
387 gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
388 #endif
390 _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
391 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
393 _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
394 }
396 static void
397 sp_color_notebook_destroy (GtkObject *object)
398 {
399 if (((GtkObjectClass *) (parent_class))->destroy)
400 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
401 }
403 ColorNotebook::~ColorNotebook()
404 {
405 if ( _trackerList )
406 {
407 g_ptr_array_free (_trackerList, TRUE);
408 _trackerList = 0;
409 }
411 if ( _switchId )
412 {
413 if ( _book )
414 {
415 g_signal_handler_disconnect (_book, _switchId);
416 _switchId = 0;
417 }
418 }
419 }
421 static void
422 sp_color_notebook_show_all (GtkWidget *widget)
423 {
424 gtk_widget_show (widget);
425 }
427 static void
428 sp_color_notebook_hide_all (GtkWidget *widget)
429 {
430 gtk_widget_hide (widget);
431 }
433 GtkWidget *
434 sp_color_notebook_new (void)
435 {
436 SPColorNotebook *colorbook;
438 colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
440 return GTK_WIDGET (colorbook);
441 }
443 ColorNotebook::ColorNotebook( SPColorSelector* csel )
444 : ColorSelector( csel )
445 {
446 }
448 SPColorSelector* ColorNotebook::getCurrentSelector()
449 {
450 SPColorSelector* csel = NULL;
451 gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
453 if ( current_page >= 0 )
454 {
455 GtkWidget* widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), current_page);
456 if ( SP_IS_COLOR_SELECTOR (widget) )
457 {
458 csel = SP_COLOR_SELECTOR (widget);
459 }
460 }
462 return csel;
463 }
465 void ColorNotebook::_colorChanged()
466 {
467 SPColorSelector* cselPage = getCurrentSelector();
468 if ( cselPage )
469 {
470 cselPage->base->setColorAlpha( _color, _alpha );
471 }
473 _updateRgbaEntry( _color, _alpha );
474 }
476 void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
477 {
478 ((ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
479 }
481 void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
482 {
483 if (_updating) return;
484 if (_updatingrgba) return;
486 const gchar *t = gtk_entry_get_text( entry );
488 if (t) {
489 Glib::ustring text = t;
490 bool changed = false;
491 if (!text.empty() && text[0] == '#') {
492 changed = true;
493 text.erase(0,1);
494 if (text.size() == 6) {
495 // it was a standard RGB hex
496 unsigned int alph = SP_COLOR_F_TO_U(_alpha);
497 gchar* tmp = g_strdup_printf("%02x", alph);
498 text += tmp;
499 g_free(tmp);
500 }
501 }
502 gchar* str = g_strdup(text.c_str());
503 gchar* end = 0;
504 guint64 rgba = g_ascii_strtoull( str, &end, 16 );
505 if ( end != str ) {
506 ptrdiff_t len = end - str;
507 if ( len < 8 ) {
508 rgba = rgba << ( 4 * ( 8 - len ) );
509 }
510 _updatingrgba = TRUE;
511 if ( changed ) {
512 gtk_entry_set_text( entry, str );
513 }
514 SPColor color( rgba );
515 setColorAlpha( color, SP_RGBA32_A_F(rgba), true );
516 _updatingrgba = FALSE;
517 }
518 g_free(str);
519 }
520 }
522 void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
523 {
524 g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
526 #if ENABLE_LCMS
527 /* update color management icon*/
528 gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
530 /* update out-of-gamut icon */
531 gtk_widget_set_sensitive (_box_outofgamut, false);
532 if (color.icc){
533 Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
534 if ( target_profile )
535 gtk_widget_set_sensitive (_box_outofgamut, target_profile->GamutCheck(color));
536 }
538 /* update too-much-ink icon */
539 gtk_widget_set_sensitive (_box_toomuchink, false);
540 if (color.icc){
541 Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
542 if (prof->getColorSpace() == icSigCmykData || prof->getColorSpace() == icSigCmyData){
543 gtk_widget_show(GTK_WIDGET(_box_toomuchink));
544 double ink_sum = 0;
545 for (unsigned int i=0; i<color.icc->colors.size(); i++){
546 ink_sum += color.icc->colors[i];
547 }
549 /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color,
550 which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues
551 such as misalignment and poor quality of printing in general.*/
552 if ( ink_sum > 3.2 )
553 gtk_widget_set_sensitive (_box_toomuchink, true);
554 } else {
555 gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
556 }
557 }
558 #endif //ENABLE_LCMS
560 if ( !_updatingrgba )
561 {
562 gchar s[32];
563 guint32 rgba;
565 /* Update RGBA entry */
566 rgba = color.toRGBA32( alpha );
568 g_snprintf (s, 32, "%08x", rgba);
569 const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
570 if ( strcmp( oldText, s ) != 0 )
571 {
572 g_signal_handler_block( _rgbae, _entryId );
573 gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
574 g_signal_handler_unblock( _rgbae, _entryId );
575 }
576 }
577 }
579 void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
580 {
581 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
582 nb->_grabbed();
583 }
585 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
586 {
587 gboolean oldState;
588 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
590 oldState = nb->_dragging;
592 nb->_dragging = TRUE;
593 nb->_entryModified( csel, colorbook );
595 nb->_dragging = oldState;
596 }
598 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
599 {
600 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
601 nb->_released();
602 }
604 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
605 {
606 gboolean oldState;
607 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
609 oldState = nb->_dragging;
611 nb->_dragging = FALSE;
612 nb->_entryModified( csel, colorbook );
614 nb->_dragging = oldState;
615 }
617 void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
618 {
619 g_return_if_fail (colorbook != NULL);
620 g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
621 g_return_if_fail (csel != NULL);
622 g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
624 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
625 SPColor color;
626 gfloat alpha = 1.0;
628 csel->base->getColorAlpha( color, &alpha );
629 nb->_updateRgbaEntry( color, alpha );
630 nb->_updateInternals( color, alpha, nb->_dragging );
631 }
633 GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
634 {
635 GtkWidget *page;
637 page = sp_color_selector_new( page_type );
638 if ( page )
639 {
640 GtkWidget* tab_label = 0;
641 SPColorSelector* csel;
643 csel = SP_COLOR_SELECTOR (page);
644 if ( submode > 0 )
645 {
646 csel->base->setSubmode( submode );
647 }
648 gtk_widget_show (page);
649 int index = csel->base ? csel->base->getSubmode() : 0;
650 const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
651 // g_message( "Hitting up for tab for '%s'", str );
652 tab_label = gtk_label_new(_(str));
653 gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
654 gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
655 gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
656 gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
657 gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
658 }
660 return page;
661 }
663 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
664 {
665 gint count = 0;
666 gint i = 0;
667 GtkWidget* page = 0;
669 // count = gtk_notebook_get_n_pages (_book);
670 count = 200;
671 for ( i = 0; i < count && !page; i++ )
672 {
673 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
674 if ( page )
675 {
676 SPColorSelector* csel;
677 guint pagemode;
678 csel = SP_COLOR_SELECTOR (page);
679 pagemode = csel->base->getSubmode();
680 if ( G_TYPE_FROM_INSTANCE (page) == page_type
681 && pagemode == submode )
682 {
683 // found it.
684 break;
685 }
686 else
687 {
688 page = 0;
689 }
690 }
691 else
692 {
693 break;
694 }
695 }
696 return page;
697 }
699 void ColorNotebook::removePage( GType page_type, guint submode )
700 {
701 GtkWidget *page = 0;
703 page = getPage(page_type, submode);
704 if ( page )
705 {
706 gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
707 if ( where >= 0 )
708 {
709 if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
710 {
711 // getColorAlpha(_color, &_alpha);
712 }
713 gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
714 }
715 }
716 }
718 /*
719 Local Variables:
720 mode:c++
721 c-file-style:"stroustrup"
722 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
723 indent-tabs-mode:nil
724 fill-column:99
725 End:
726 */
727 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :