56b60d1206e678074bead2d82a6158e68fe220c6
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 //the "too much ink" icon is initially hidden
378 gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
380 gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
382 #ifdef SPCS_PREVIEW
383 _p = sp_color_preview_new (0xffffffff);
384 gtk_widget_show (_p);
385 gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
386 #endif
388 _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
389 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
391 _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
392 }
394 static void
395 sp_color_notebook_destroy (GtkObject *object)
396 {
397 if (((GtkObjectClass *) (parent_class))->destroy)
398 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
399 }
401 ColorNotebook::~ColorNotebook()
402 {
403 if ( _trackerList )
404 {
405 g_ptr_array_free (_trackerList, TRUE);
406 _trackerList = 0;
407 }
409 if ( _switchId )
410 {
411 if ( _book )
412 {
413 g_signal_handler_disconnect (_book, _switchId);
414 _switchId = 0;
415 }
416 }
417 }
419 static void
420 sp_color_notebook_show_all (GtkWidget *widget)
421 {
422 gtk_widget_show (widget);
423 }
425 static void
426 sp_color_notebook_hide_all (GtkWidget *widget)
427 {
428 gtk_widget_hide (widget);
429 }
431 GtkWidget *
432 sp_color_notebook_new (void)
433 {
434 SPColorNotebook *colorbook;
436 colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
438 return GTK_WIDGET (colorbook);
439 }
441 ColorNotebook::ColorNotebook( SPColorSelector* csel )
442 : ColorSelector( csel )
443 {
444 }
446 SPColorSelector* ColorNotebook::getCurrentSelector()
447 {
448 SPColorSelector* csel = NULL;
449 gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
451 if ( current_page >= 0 )
452 {
453 GtkWidget* widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), current_page);
454 if ( SP_IS_COLOR_SELECTOR (widget) )
455 {
456 csel = SP_COLOR_SELECTOR (widget);
457 }
458 }
460 return csel;
461 }
463 void ColorNotebook::_colorChanged()
464 {
465 SPColorSelector* cselPage = getCurrentSelector();
466 if ( cselPage )
467 {
468 cselPage->base->setColorAlpha( _color, _alpha );
469 }
471 _updateRgbaEntry( _color, _alpha );
472 }
474 void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
475 {
476 ((ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
477 }
479 void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
480 {
481 if (_updating) return;
482 if (_updatingrgba) return;
484 const gchar *t = gtk_entry_get_text( entry );
486 if (t) {
487 Glib::ustring text = t;
488 bool changed = false;
489 if (!text.empty() && text[0] == '#') {
490 changed = true;
491 text.erase(0,1);
492 if (text.size() == 6) {
493 // it was a standard RGB hex
494 unsigned int alph = SP_COLOR_F_TO_U(_alpha);
495 gchar* tmp = g_strdup_printf("%02x", alph);
496 text += tmp;
497 g_free(tmp);
498 }
499 }
500 gchar* str = g_strdup(text.c_str());
501 gchar* end = 0;
502 guint64 rgba = g_ascii_strtoull( str, &end, 16 );
503 if ( end != str ) {
504 ptrdiff_t len = end - str;
505 if ( len < 8 ) {
506 rgba = rgba << ( 4 * ( 8 - len ) );
507 }
508 _updatingrgba = TRUE;
509 if ( changed ) {
510 gtk_entry_set_text( entry, str );
511 }
512 SPColor color( rgba );
513 setColorAlpha( color, SP_RGBA32_A_F(rgba), true );
514 _updatingrgba = FALSE;
515 }
516 g_free(str);
517 }
518 }
520 void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
521 {
522 g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
524 #if ENABLE_LCMS
525 /* update color management icon*/
526 gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
528 /* update out-of-gamut icon */
529 gtk_widget_set_sensitive (_box_outofgamut, false);
530 if (color.icc){
531 Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
532 if ( target_profile )
533 gtk_widget_set_sensitive (_box_outofgamut, target_profile->GamutCheck(color));
534 }
536 /* update too-much-ink icon */
537 gtk_widget_set_sensitive (_box_toomuchink, false);
538 if (color.icc){
539 Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
540 if (prof->getColorSpace() == icSigCmykData || prof->getColorSpace() == icSigCmyData){
541 gtk_widget_show(GTK_WIDGET(_box_toomuchink));
542 double ink_sum = 0;
543 for (unsigned int i=0; i<color.icc->colors.size(); i++){
544 ink_sum += color.icc->colors[i];
545 }
547 /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color,
548 which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues
549 such as misalignment and poor quality of printing in general.*/
550 if ( ink_sum > 3.2 )
551 gtk_widget_set_sensitive (_box_toomuchink, true);
552 } else {
553 gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
554 }
555 }
556 #endif //ENABLE_LCMS
558 if ( !_updatingrgba )
559 {
560 gchar s[32];
561 guint32 rgba;
563 /* Update RGBA entry */
564 rgba = color.toRGBA32( alpha );
566 g_snprintf (s, 32, "%08x", rgba);
567 const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
568 if ( strcmp( oldText, s ) != 0 )
569 {
570 g_signal_handler_block( _rgbae, _entryId );
571 gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
572 g_signal_handler_unblock( _rgbae, _entryId );
573 }
574 }
575 }
577 void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
578 {
579 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
580 nb->_grabbed();
581 }
583 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
584 {
585 gboolean oldState;
586 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
588 oldState = nb->_dragging;
590 nb->_dragging = TRUE;
591 nb->_entryModified( csel, colorbook );
593 nb->_dragging = oldState;
594 }
596 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
597 {
598 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
599 nb->_released();
600 }
602 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
603 {
604 gboolean oldState;
605 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
607 oldState = nb->_dragging;
609 nb->_dragging = FALSE;
610 nb->_entryModified( csel, colorbook );
612 nb->_dragging = oldState;
613 }
615 void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
616 {
617 g_return_if_fail (colorbook != NULL);
618 g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
619 g_return_if_fail (csel != NULL);
620 g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
622 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
623 SPColor color;
624 gfloat alpha = 1.0;
626 csel->base->getColorAlpha( color, &alpha );
627 nb->_updateRgbaEntry( color, alpha );
628 nb->_updateInternals( color, alpha, nb->_dragging );
629 }
631 GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
632 {
633 GtkWidget *page;
635 page = sp_color_selector_new( page_type );
636 if ( page )
637 {
638 GtkWidget* tab_label = 0;
639 SPColorSelector* csel;
641 csel = SP_COLOR_SELECTOR (page);
642 if ( submode > 0 )
643 {
644 csel->base->setSubmode( submode );
645 }
646 gtk_widget_show (page);
647 int index = csel->base ? csel->base->getSubmode() : 0;
648 const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
649 // g_message( "Hitting up for tab for '%s'", str );
650 tab_label = gtk_label_new(_(str));
651 gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
652 gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
653 gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
654 gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
655 gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
656 }
658 return page;
659 }
661 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
662 {
663 gint count = 0;
664 gint i = 0;
665 GtkWidget* page = 0;
667 // count = gtk_notebook_get_n_pages (_book);
668 count = 200;
669 for ( i = 0; i < count && !page; i++ )
670 {
671 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
672 if ( page )
673 {
674 SPColorSelector* csel;
675 guint pagemode;
676 csel = SP_COLOR_SELECTOR (page);
677 pagemode = csel->base->getSubmode();
678 if ( G_TYPE_FROM_INSTANCE (page) == page_type
679 && pagemode == submode )
680 {
681 // found it.
682 break;
683 }
684 else
685 {
686 page = 0;
687 }
688 }
689 else
690 {
691 break;
692 }
693 }
694 return page;
695 }
697 void ColorNotebook::removePage( GType page_type, guint submode )
698 {
699 GtkWidget *page = 0;
701 page = getPage(page_type, submode);
702 if ( page )
703 {
704 gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
705 if ( where >= 0 )
706 {
707 if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
708 {
709 // getColorAlpha(_color, &_alpha);
710 }
711 gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
712 }
713 }
714 }
716 /*
717 Local Variables:
718 mode:c++
719 c-file-style:"stroustrup"
720 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
721 indent-tabs-mode:nil
722 fill-column:99
723 End:
724 */
725 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :