X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fwidgets%2Fdesktop-widget.cpp;h=4be82339140ad104cb165308dc87aebedd8f9f16;hb=690d37ddd3470e494dde1e3ee20b942736e734d2;hp=311f93a1c1a70b7f468df18a937aa71af22df95a;hpb=cfd67b23e1f172e3ea834b42805d04bc7b0013e8;p=inkscape.git diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp index 311f93a1c..4be823391 100644 --- a/src/widgets/desktop-widget.cpp +++ b/src/widgets/desktop-widget.cpp @@ -8,7 +8,11 @@ * MenTaLguY * bulia byak * Ralf Stephan + * John Bintz + * Johan Engelen * + * Copyright (C) 2007 Johan Engelen + * Copyright (C) 2006 John Bintz * Copyright (C) 2004 MenTaLguY * Copyright (C) 1999-2002 Lauris Kaplinski * Copyright (C) 2000-2001 Ximian, Inc. @@ -33,8 +37,10 @@ #include "interface.h" #include "toolbox.h" #include "prefs-utils.h" +#include "preferences.h" #include "file.h" #include "display/canvas-arena.h" +#include "display/nr-arena.h" #include #include "helper/units.h" #include "widgets/button.h" @@ -43,10 +49,23 @@ #include "widgets/spw-utilities.h" #include "widgets/spinbutton-events.h" #include "widgets/layer-selector.h" +#include "ui/dialog/dialog-manager.h" +#include "ui/widget/dock.h" #include "ui/widget/selected-style.h" #include "sp-item.h" #include "dialogs/swatches.h" #include "conn-avoid-ref.h" +#include "ege-select-one-action.h" +#include "ege-color-prof-tracker.h" +#include "color-profile-fns.h" +#include "xml/node-observer.h" +#include "box3d-context.h" +#include "sp-image.h" + +#if defined (SOLARIS) && (SOLARIS == 8) +#include "round.h" +using Inkscape::round; +#endif #ifdef WITH_INKBOARD #endif @@ -74,10 +93,11 @@ static void sp_desktop_widget_realize (GtkWidget *widget); static gint sp_desktop_widget_event (GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw); - - +static void sp_dtw_color_profile_event(EgeColorProfTracker *widget, SPDesktopWidget *dtw); +static void cms_adjust_toggled( GtkWidget *button, gpointer data ); +static void cms_adjust_set_sensitive( SPDesktopWidget *dtw, bool enabled ); static void sp_desktop_widget_adjustment_value_changed (GtkAdjustment *adj, SPDesktopWidget *dtw); -static void sp_desktop_widget_namedview_modified (SPNamedView *nv, guint flags, SPDesktopWidget *dtw); +static void sp_desktop_widget_namedview_modified (SPObject *obj, guint flags, SPDesktopWidget *dtw); static gdouble sp_dtw_zoom_value_to_display (gdouble value); static gdouble sp_dtw_zoom_display_to_value (gdouble value); @@ -95,40 +115,152 @@ static void sp_dtw_zoom_selection (GtkMenuItem *item, gpointer data); SPViewWidgetClass *dtw_parent_class; -void +using Inkscape::XML::Node; + +class PrefWatcher : public Inkscape::XML::NodeObserver { +public: + PrefWatcher(); + virtual ~PrefWatcher(); + + + virtual void notifyChildAdded( Node &/*node*/, Node &/*child*/, Node */*prev*/ ) {} + virtual void notifyChildRemoved( Node &/*node*/, Node &/*child*/, Node */*prev*/ ) {} + virtual void notifyChildOrderChanged( Node &/*node*/, Node &/*child*/, + Node */*old_prev*/, Node */*new_prev*/ ) {} + virtual void notifyContentChanged( Node &/*node*/, + Inkscape::Util::ptr_shared /*old_content*/, + Inkscape::Util::ptr_shared /*new_content*/ ) {} + virtual void notifyAttributeChanged( Node &node, GQuark name, + Inkscape::Util::ptr_shared old_value, + Inkscape::Util::ptr_shared new_value ); + void add( SPDesktopWidget* dtw ); + void remove( SPDesktopWidget* dtw ); + +private: + static void hook(EgeColorProfTracker *tracker, gint a, gint b, PrefWatcher *watcher); + + std::list dtws; + EgeColorProfTracker *_tracker; +}; + +PrefWatcher::PrefWatcher() : + NodeObserver(), + dtws(), + _tracker(0) +{ + _tracker = ege_color_prof_tracker_new(0); + g_signal_connect( G_OBJECT(_tracker), "modified", G_CALLBACK(hook), this ); +} + +PrefWatcher::~PrefWatcher() +{ +} + +void PrefWatcher::hook(EgeColorProfTracker */*tracker*/, gint screen, gint monitor, PrefWatcher */*watcher*/) +{ +#if ENABLE_LCMS + unsigned char* buf = 0; + guint len = 0; + + ege_color_prof_tracker_get_profile_for( screen, monitor, reinterpret_cast(&buf), &len ); + Glib::ustring id = Inkscape::colorprofile_set_display_per( buf, len, screen, monitor ); +#endif // ENABLE_LCMS +} + +void PrefWatcher::add( SPDesktopWidget* dtw ) +{ + dtws.push_back(dtw); +} + +void PrefWatcher::remove( SPDesktopWidget* dtw ) +{ + dtws.remove(dtw); +} + +void PrefWatcher::notifyAttributeChanged( Node &node, GQuark name, + Inkscape::Util::ptr_shared /*old_value*/, + Inkscape::Util::ptr_shared /*new_value*/ ) +{ +#if ENABLE_LCMS + (void)name; + if ( strcmp("group", node.name()) == 0 ) { + gchar const* id = node.attribute("id"); + bool refresh = false; + if ( !id ) { + // bad + } else if (strcmp("displayprofile", id) == 0) { + Glib::ustring current = prefs_get_string_attribute( "options.displayprofile", "uri" ); + bool enabled = current.length() > 0; + + for ( std::list::iterator it = dtws.begin(); it != dtws.end(); ++it ) { + SPDesktopWidget* dtw = *it; + if ( GTK_WIDGET_SENSITIVE( dtw->cms_adjust ) != enabled ) { + cms_adjust_set_sensitive( dtw, enabled ); + } + } + refresh = true; + } else if (strcmp("softproof", id) == 0) { + refresh = true; + } + + if ( refresh ) { + for ( std::list::iterator it = dtws.begin(); it != dtws.end(); ++it ) { + (*it)->requestCanvasUpdate(); + } + } +#else + { + (void)node; + (void)name; +#endif // ENABLE_LCMS + } +} + +static PrefWatcher* watcher = 0; + +void SPDesktopWidget::setMessage (Inkscape::MessageType type, const gchar *message) { GtkLabel *sb=GTK_LABEL(this->select_status); gtk_label_set_markup (sb, message ? message : ""); - // FIXME: TODO: remove before displaying as tooltip - gtk_tooltips_set_tip (this->tt, this->select_status_eventbox, message ? message : "", NULL); + + // make sure the important messages are displayed immediately! + if (type == Inkscape::IMMEDIATE_MESSAGE && GTK_WIDGET_DRAWABLE (GTK_WIDGET(sb))) { + gtk_widget_queue_draw(GTK_WIDGET(sb)); + gdk_window_process_updates(GTK_WIDGET(sb)->window, TRUE); + } + + gtk_tooltips_set_tip (this->tt, this->select_status_eventbox, gtk_label_get_text (sb) , NULL); } -NR::Point +Geom::Point SPDesktopWidget::window_get_pointer() { gint x,y; gdk_window_get_pointer (GTK_WIDGET (canvas)->window, &x, &y, NULL); - return NR::Point(x,y); + return Geom::Point(x,y); } /** * Registers SPDesktopWidget class and returns its type number. */ -GtkType -sp_desktop_widget_get_type (void) +GType sp_desktop_widget_get_type(void) { static GtkType type = 0; if (!type) { - static const GtkTypeInfo info = { - "SPDesktopWidget", - sizeof (SPDesktopWidget), - sizeof (SPDesktopWidgetClass), - (GtkClassInitFunc) sp_desktop_widget_class_init, - (GtkObjectInitFunc) sp_desktop_widget_init, - NULL, NULL, NULL + GTypeInfo info = { + sizeof(SPDesktopWidgetClass), + 0, // base_init + 0, // base_finalize + (GClassInitFunc)sp_desktop_widget_class_init, + 0, // class_finalize + 0, // class_data + sizeof(SPDesktopWidget), + 0, // n_preallocs + (GInstanceInitFunc)sp_desktop_widget_init, + 0 // value_table }; - type = gtk_type_unique (SP_TYPE_VIEW_WIDGET, &info); + type = g_type_register_static(SP_TYPE_VIEW_WIDGET, "SPDesktopWidget", &info, static_cast(0)); } return type; } @@ -158,30 +290,27 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) { GtkWidget *widget; GtkWidget *tbl; - GtkWidget *w; + GtkWidget *canvas_tbl; GtkWidget *hbox; GtkWidget *eventbox; GtkStyle *style; - widget = GTK_WIDGET (dtw); + new (&dtw->modified_connection) sigc::connection(); - Gtk::VPaned* pane = manage( new Gtk::VPaned() ); - pane->show_all(); + widget = GTK_WIDGET (dtw); dtw->window = 0; - + dtw->desktop = NULL; + dtw->_interaction_disabled_counter = 0; + dtw->tt = gtk_tooltips_new (); /* Main table */ dtw->vbox = gtk_vbox_new (FALSE, 0); - gtk_container_add( GTK_CONTAINER(dtw), GTK_WIDGET(pane->gobj()) ); - - Gtk::VBox* tmp = Glib::wrap( GTK_VBOX(dtw->vbox) ); - Gtk::VBox* boxWrap = manage( tmp ); - pane->pack1( *boxWrap, true, true ); + gtk_container_add( GTK_CONTAINER(dtw), GTK_WIDGET(dtw->vbox) ); dtw->statusbar = gtk_hbox_new (FALSE, 0); //gtk_widget_set_usize (dtw->statusbar, -1, BOTTOM_BAR_HEIGHT); @@ -190,9 +319,10 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) { using Inkscape::UI::Dialogs::SwatchesPanel; - SwatchesPanel* swatches = manage( new SwatchesPanel() ); + SwatchesPanel* swatches = new SwatchesPanel("embedded.swatches"); + swatches->setOrientation( Gtk::ANCHOR_SOUTH ); dtw->panels = GTK_WIDGET(swatches->gobj()); - pane->pack2( *swatches, false, true ); + gtk_box_pack_end( GTK_BOX( dtw->vbox ), dtw->panels, FALSE, TRUE, 0 ); } hbox = gtk_hbox_new (FALSE, 0); @@ -208,9 +338,11 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) dtw->tool_toolbox = sp_tool_toolbox_new (); gtk_box_pack_start (GTK_BOX (hbox), dtw->tool_toolbox, FALSE, TRUE, 0); - tbl = gtk_table_new (4, 3, FALSE); + tbl = gtk_table_new (2, 3, FALSE); gtk_box_pack_start (GTK_BOX (hbox), tbl, TRUE, TRUE, 1); + canvas_tbl = gtk_table_new (3, 3, FALSE); + /* Horizontal ruler */ eventbox = gtk_event_box_new (); dtw->hruler = sp_hruler_new (); @@ -218,7 +350,7 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) sp_ruler_set_metric (GTK_RULER (dtw->hruler), SP_PT); gtk_tooltips_set_tip (dtw->tt, dtw->hruler_box, gettext(sp_unit_get_plural (&sp_unit_get_by_id(SP_UNIT_PT))), NULL); gtk_container_add (GTK_CONTAINER (eventbox), dtw->hruler); - gtk_table_attach (GTK_TABLE (tbl), eventbox, 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), widget->style->xthickness, 0); + gtk_table_attach (GTK_TABLE (canvas_tbl), eventbox, 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), widget->style->xthickness, 0); g_signal_connect (G_OBJECT (eventbox), "button_press_event", G_CALLBACK (sp_dt_hruler_event), dtw); g_signal_connect (G_OBJECT (eventbox), "button_release_event", G_CALLBACK (sp_dt_hruler_event), dtw); g_signal_connect (G_OBJECT (eventbox), "motion_notify_event", G_CALLBACK (sp_dt_hruler_event), dtw); @@ -230,7 +362,7 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) sp_ruler_set_metric (GTK_RULER (dtw->vruler), SP_PT); gtk_tooltips_set_tip (dtw->tt, dtw->vruler_box, gettext(sp_unit_get_plural (&sp_unit_get_by_id(SP_UNIT_PT))), NULL); gtk_container_add (GTK_CONTAINER (eventbox), GTK_WIDGET (dtw->vruler)); - gtk_table_attach (GTK_TABLE (tbl), eventbox, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, widget->style->ythickness); + gtk_table_attach (GTK_TABLE (canvas_tbl), eventbox, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, widget->style->ythickness); g_signal_connect (G_OBJECT (eventbox), "button_press_event", G_CALLBACK (sp_dt_vruler_event), dtw); g_signal_connect (G_OBJECT (eventbox), "button_release_event", G_CALLBACK (sp_dt_vruler_event), dtw); g_signal_connect (G_OBJECT (eventbox), "motion_notify_event", G_CALLBACK (sp_dt_vruler_event), dtw); @@ -238,10 +370,11 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) /* Horizontal scrollbar */ dtw->hadj = (GtkAdjustment *) gtk_adjustment_new (0.0, -4000.0, 4000.0, 10.0, 100.0, 4.0); dtw->hscrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (dtw->hadj)); - gtk_table_attach (GTK_TABLE (tbl), dtw->hscrollbar, 1, 2, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0); + gtk_table_attach (GTK_TABLE (canvas_tbl), dtw->hscrollbar, 1, 2, 2, 3, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_SHRINK), 0, 0); + /* Vertical scrollbar and the sticky zoom button */ dtw->vscrollbar_box = gtk_vbox_new (FALSE, 0); - dtw->sticky_zoom = sp_button_new_from_data ( GTK_ICON_SIZE_MENU, + dtw->sticky_zoom = sp_button_new_from_data ( Inkscape::ICON_SIZE_DECORATION, SP_BUTTON_TYPE_TOGGLE, NULL, "sticky_zoom", @@ -252,19 +385,92 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) dtw->vadj = (GtkAdjustment *) gtk_adjustment_new (0.0, -4000.0, 4000.0, 10.0, 100.0, 4.0); dtw->vscrollbar = gtk_vscrollbar_new (GTK_ADJUSTMENT (dtw->vadj)); gtk_box_pack_start (GTK_BOX (dtw->vscrollbar_box), dtw->vscrollbar, TRUE, TRUE, 0); - gtk_table_attach (GTK_TABLE (tbl), dtw->vscrollbar_box, 2, 3, 0, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); + gtk_table_attach (GTK_TABLE (canvas_tbl), dtw->vscrollbar_box, 2, 3, 0, 2, (GtkAttachOptions)(GTK_SHRINK), (GtkAttachOptions)(GTK_FILL), 0, 0); + + + gchar const* tip = ""; + Inkscape::Verb* verb = Inkscape::Verb::get( SP_VERB_VIEW_CMS_TOGGLE ); + if ( verb ) { + SPAction *act = verb->get_action( dtw->viewwidget.view ); + if ( act && act->tip ) { + tip = act->tip; + } + } + dtw->cms_adjust = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, + SP_BUTTON_TYPE_TOGGLE, + NULL, + "color_management", + tip, + dtw->tt ); +#if ENABLE_LCMS + { + Glib::ustring current = prefs_get_string_attribute( "options.displayprofile", "uri" ); + bool enabled = current.length() > 0; + cms_adjust_set_sensitive( dtw, enabled ); + if ( enabled ) { + long long int active = prefs_get_int_attribute_limited( "options.displayprofile", "enable", 0, 0, 1 ); + if ( active ) { + sp_button_toggle_set_down( SP_BUTTON(dtw->cms_adjust), TRUE ); + } + } + } + g_signal_connect_after( G_OBJECT(dtw->cms_adjust), "clicked", G_CALLBACK(cms_adjust_toggled), dtw ); +#else + cms_adjust_set_sensitive(dtw, FALSE); +#endif // ENABLE_LCMS + gtk_table_attach( GTK_TABLE(canvas_tbl), dtw->cms_adjust, 2, 3, 2, 3, (GtkAttachOptions)(GTK_SHRINK), (GtkAttachOptions)(GTK_SHRINK), 0, 0); + { + Inkscape::XML::Node* prefs = Inkscape::Preferences::get(); + if ( prefs ) { + if (!watcher) { + watcher = new PrefWatcher(); + prefs->addSubtreeObserver( *watcher ); + } + watcher->add(dtw); + } else { + g_warning("NULL preferences instance encountered"); + } + } /* Canvas */ - w = gtk_frame_new (NULL); - gtk_table_attach (GTK_TABLE (tbl), w, 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); dtw->canvas = SP_CANVAS (sp_canvas_new_aa ()); +#if ENABLE_LCMS + dtw->canvas->enable_cms_display_adj = prefs_get_int_attribute_limited( "options.displayprofile", "enable", 0, 0, 1 ) != 0; +#endif // ENABLE_LCMS GTK_WIDGET_SET_FLAGS (GTK_WIDGET (dtw->canvas), GTK_CAN_FOCUS); style = gtk_style_copy (GTK_WIDGET (dtw->canvas)->style); style->bg[GTK_STATE_NORMAL] = style->white; gtk_widget_set_style (GTK_WIDGET (dtw->canvas), style); - gtk_widget_set_extension_events(GTK_WIDGET (dtw->canvas) , GDK_EXTENSION_EVENTS_ALL); + if ( prefs_get_int_attribute ("options.useextinput", "value", 1) ) + gtk_widget_set_extension_events(GTK_WIDGET (dtw->canvas) , GDK_EXTENSION_EVENTS_ALL); //set extension events for tablets, unless disabled in preferences g_signal_connect (G_OBJECT (dtw->canvas), "event", G_CALLBACK (sp_desktop_widget_event), dtw); - gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (dtw->canvas)); + gtk_table_attach (GTK_TABLE (canvas_tbl), GTK_WIDGET(dtw->canvas), 1, 2, 1, 2, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), 0, 0); + + /* Dock */ + bool create_dock = + prefs_get_int_attribute_limited ("options.dialogtype", "value", Inkscape::UI::Dialog::FLOATING, 0, 1) == + Inkscape::UI::Dialog::DOCK; + + if (create_dock) { + dtw->dock = new Inkscape::UI::Widget::Dock(); + + Gtk::HPaned *paned = new Gtk::HPaned(); + paned->pack1(*Glib::wrap(canvas_tbl)); + paned->pack2(dtw->dock->getWidget(), Gtk::FILL); + + /* Prevent the paned from catching F6 and F8 by unsetting the default callbacks */ + if (GtkPanedClass *paned_class = GTK_PANED_CLASS (G_OBJECT_GET_CLASS (paned->gobj()))) { + paned_class->cycle_child_focus = NULL; + paned_class->cycle_handle_focus = NULL; + } + + gtk_table_attach (GTK_TABLE (tbl), GTK_WIDGET (paned->gobj()), 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), + (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); + + } else { + gtk_table_attach (GTK_TABLE (tbl), GTK_WIDGET (canvas_tbl), 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), + (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); + } dtw->selected_style = new Inkscape::UI::Widget::SelectedStyle(true); GtkHBox *ss_ = dtw->selected_style->gobj(); @@ -308,10 +514,12 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) GtkWidget *label_y = gtk_label_new("Y:"); gtk_misc_set_alignment (GTK_MISC(label_y), 0.0, 0.5); gtk_table_attach(GTK_TABLE(dtw->coord_status), label_y, 1,2, 1,2, GTK_FILL, GTK_FILL, 0, 0); - dtw->coord_status_x = gtk_label_new("0.0"); - gtk_misc_set_alignment (GTK_MISC(dtw->coord_status_x), 0.0, 0.5); - dtw->coord_status_y = gtk_label_new("0.0"); - gtk_misc_set_alignment (GTK_MISC(dtw->coord_status_y), 0.0, 0.5); + dtw->coord_status_x = gtk_label_new(NULL); + gtk_label_set_markup( GTK_LABEL(dtw->coord_status_x), " 0.00 " ); + gtk_misc_set_alignment (GTK_MISC(dtw->coord_status_x), 1.0, 0.5); + dtw->coord_status_y = gtk_label_new(NULL); + gtk_label_set_markup( GTK_LABEL(dtw->coord_status_y), " 0.00 " ); + gtk_misc_set_alignment (GTK_MISC(dtw->coord_status_y), 1.0, 0.5); gtk_table_attach(GTK_TABLE(dtw->coord_status), dtw->coord_status_x, 2,3, 0,1, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(dtw->coord_status), dtw->coord_status_y, 2,3, 1,2, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(dtw->coord_status), gtk_label_new("Z:"), 3,4, 0,2, GTK_FILL, GTK_FILL, 0, 0); @@ -325,6 +533,20 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) //dtw->layer_selector->set_size_request(-1, SP_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(dtw->statusbar), GTK_WIDGET(dtw->layer_selector->gobj()), FALSE, FALSE, 1); + dtw->_tracker = ege_color_prof_tracker_new(GTK_WIDGET(dtw->layer_selector->gobj())); +#if ENABLE_LCMS + { + Glib::ustring id = Inkscape::colorprofile_get_display_id( 0, 0 ); + bool enabled = false; + if ( dtw->canvas->cms_key ) { + *(dtw->canvas->cms_key) = id; + enabled = !dtw->canvas->cms_key->empty(); + } + cms_adjust_set_sensitive( dtw, enabled ); + } +#endif // ENABLE_LCMS + g_signal_connect( G_OBJECT(dtw->_tracker), "changed", G_CALLBACK(sp_dtw_color_profile_event), dtw ); + dtw->select_status_eventbox = gtk_event_box_new (); dtw->select_status = gtk_label_new (NULL); #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 6 @@ -351,14 +573,26 @@ sp_desktop_widget_destroy (GtkObject *object) SPDesktopWidget *dtw = SP_DESKTOP_WIDGET (object); if (dtw->desktop) { + if ( watcher ) { + watcher->remove(dtw); + } + g_signal_handlers_disconnect_by_func(G_OBJECT (dtw->zoom_status), (gpointer) G_CALLBACK(sp_dtw_zoom_input), dtw); + g_signal_handlers_disconnect_by_func(G_OBJECT (dtw->zoom_status), (gpointer) G_CALLBACK(sp_dtw_zoom_output), dtw); + gtk_signal_disconnect_by_data (GTK_OBJECT (dtw->zoom_status), dtw->zoom_status); + g_signal_handlers_disconnect_by_func (G_OBJECT (dtw->zoom_status), (gpointer) G_CALLBACK (sp_dtw_zoom_value_changed), dtw); + g_signal_handlers_disconnect_by_func (G_OBJECT (dtw->zoom_status), (gpointer) G_CALLBACK (sp_dtw_zoom_populate_popup), dtw); + g_signal_handlers_disconnect_by_func (G_OBJECT (dtw->canvas), (gpointer) G_CALLBACK (sp_desktop_widget_event), dtw); + dtw->layer_selector->unreference(); inkscape_remove_desktop (dtw->desktop); // clears selection too - sp_signal_disconnect_by_data (G_OBJECT (dtw->desktop->namedview), dtw); + dtw->modified_connection.disconnect(); dtw->desktop->destroy(); Inkscape::GC::release (dtw->desktop); dtw->desktop = NULL; } + dtw->modified_connection.~connection(); + if (GTK_OBJECT_CLASS (dtw_parent_class)->destroy) { (* GTK_OBJECT_CLASS (dtw_parent_class)->destroy) (object); } @@ -367,29 +601,44 @@ sp_desktop_widget_destroy (GtkObject *object) /** * Set the title in the desktop-window (if desktop has an own window). - * + * * The title has form file name: desktop number - Inkscape. * The desktop number is only shown if it's 2 or higher, */ void SPDesktopWidget::updateTitle(gchar const* uri) { - GtkWindow *window = GTK_WINDOW (gtk_object_get_data (GTK_OBJECT(this), "window")); + Gtk::Window *window = (Gtk::Window*)gtk_object_get_data (GTK_OBJECT(this), "window"); + if (window) { gchar const *fname = ( TRUE ? uri : g_basename(uri) ); GString *name = g_string_new (""); if (this->desktop->number > 1) { - g_string_printf (name, _("%s: %d - Inkscape"), fname, this->desktop->number); + if (this->desktop->getMode() == Inkscape::RENDERMODE_OUTLINE) { + g_string_printf (name, _("%s: %d (outline) - Inkscape"), fname, this->desktop->number); + } else { + g_string_printf (name, _("%s: %d - Inkscape"), fname, this->desktop->number); + } } else { - g_string_printf (name, _("%s - Inkscape"), fname); + if (this->desktop->getMode() == Inkscape::RENDERMODE_OUTLINE) { + g_string_printf (name, _("%s (outline) - Inkscape"), fname); + } else { + g_string_printf (name, _("%s - Inkscape"), fname); + } } - gtk_window_set_title (window, name->str); + window->set_title (name->str); g_string_free (name, TRUE); } } +Inkscape::UI::Widget::Dock* +SPDesktopWidget::getDock() +{ + return dock; +} + /** * Callback to allocate space for desktop widget. */ @@ -408,7 +657,7 @@ sp_desktop_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation) } if (GTK_WIDGET_REALIZED (widget)) { - NR::Rect const area = dtw->desktop->get_display_area(); + Geom::Rect const area = to_2geom(dtw->desktop->get_display_area()); double zoom = dtw->desktop->current_zoom(); if (GTK_WIDGET_CLASS(dtw_parent_class)->size_allocate) { @@ -417,14 +666,14 @@ sp_desktop_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation) if (SP_BUTTON_IS_DOWN(dtw->sticky_zoom)) { /* Calculate zoom per pixel */ - double const zpsp = zoom / hypot (area.dimensions()[NR::X], area.dimensions()[NR::Y]); + double const zpsp = zoom / hypot (area.dimensions()[Geom::X], area.dimensions()[Geom::Y]); /* Find new visible area */ - NR::Rect newarea = dtw->desktop->get_display_area(); + Geom::Rect newarea = to_2geom(dtw->desktop->get_display_area()); /* Calculate adjusted zoom */ - zoom = zpsp * hypot(newarea.dimensions()[NR::X], newarea.dimensions()[NR::Y]); - dtw->desktop->zoom_absolute(newarea.midpoint()[NR::X], newarea.midpoint()[NR::Y], zoom); + zoom = zpsp * hypot(newarea.dimensions()[Geom::X], newarea.dimensions()[Geom::Y]); + dtw->desktop->zoom_absolute(newarea.midpoint()[Geom::X], newarea.midpoint()[Geom::Y], zoom); } else { - dtw->desktop->zoom_absolute(area.midpoint()[NR::X], area.midpoint()[NR::Y], zoom); + dtw->desktop->zoom_absolute(area.midpoint()[Geom::X], area.midpoint()[Geom::Y], zoom); } } else { @@ -457,8 +706,20 @@ sp_desktop_widget_realize (GtkWidget *widget) dtw->desktop->set_display_area (d.x0, d.y0, d.x1, d.y1, 10); + sp_desktop_widget_update_namedview(dtw); +} + +/* This is just to provide access to common functionality from sp_desktop_widget_realize() above + as well as from SPDesktop::change_document() */ +void +sp_desktop_widget_update_namedview (SPDesktopWidget *dtw) { + g_return_if_fail(dtw); + /* Listen on namedview modification */ - g_signal_connect (G_OBJECT (dtw->desktop->namedview), "modified", G_CALLBACK (sp_desktop_widget_namedview_modified), dtw); + // originally (prior to the sigc++ conversion) the signal was simply + // connected twice rather than disconnecting the first connection + dtw->modified_connection.disconnect(); + dtw->modified_connection = dtw->desktop->namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_desktop_widget_namedview_modified), dtw)); sp_desktop_widget_namedview_modified (dtw->desktop->namedview, SP_OBJECT_MODIFIED_FLAG, dtw); dtw->updateTitle(SP_DOCUMENT_NAME (dtw->desktop->doc())); @@ -499,14 +760,58 @@ sp_desktop_widget_event (GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dt return FALSE; } +void sp_dtw_color_profile_event(EgeColorProfTracker */*tracker*/, SPDesktopWidget *dtw) +{ +#if ENABLE_LCMS + // Handle profile changes + GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET(dtw)); + gint screenNum = gdk_screen_get_number(screen); + gint monitor = gdk_screen_get_monitor_at_window(screen, gtk_widget_get_toplevel(GTK_WIDGET(dtw))->window); + Glib::ustring id = Inkscape::colorprofile_get_display_id( screenNum, monitor ); + bool enabled = false; + if ( dtw->canvas->cms_key ) { + *(dtw->canvas->cms_key) = id; + dtw->requestCanvasUpdate(); + enabled = !dtw->canvas->cms_key->empty(); + } + cms_adjust_set_sensitive( dtw, enabled ); +#endif // ENABLE_LCMS +} + +void cms_adjust_toggled( GtkWidget */*button*/, gpointer data ) +{ +#if ENABLE_LCMS + SPDesktopWidget *dtw = SP_DESKTOP_WIDGET(data); + + bool down = SP_BUTTON_IS_DOWN(dtw->cms_adjust); + if ( down != dtw->canvas->enable_cms_display_adj ) { + dtw->canvas->enable_cms_display_adj = down; + dtw->requestCanvasUpdate(); + prefs_set_int_attribute( "options.displayprofile", "enable", down ? 1 : 0 ); + } +#endif // ENABLE_LCMS +} + +void cms_adjust_set_sensitive( SPDesktopWidget *dtw, bool enabled ) +{ + Inkscape::Verb* verb = Inkscape::Verb::get( SP_VERB_VIEW_CMS_TOGGLE ); + if ( verb ) { + SPAction *act = verb->get_action( dtw->viewwidget.view ); + if ( act ) { + sp_action_set_sensitive( act, enabled ); + } + } + gtk_widget_set_sensitive( dtw->cms_adjust, enabled ); +} + void -sp_dtw_desktop_activate (SPDesktopWidget *dtw) +sp_dtw_desktop_activate (SPDesktopWidget */*dtw*/) { /* update active desktop indicator */ } void -sp_dtw_desktop_deactivate (SPDesktopWidget *dtw) +sp_dtw_desktop_deactivate (SPDesktopWidget */*dtw*/) { /* update inactive desktop indicator */ } @@ -517,42 +822,30 @@ sp_dtw_desktop_deactivate (SPDesktopWidget *dtw) * to save, discard, or cancel. Returns TRUE if the shutdown operation * is cancelled or if the save is cancelled or fails, FALSE otherwise. */ -bool +bool SPDesktopWidget::shutdown() { g_assert(desktop != NULL); + if (inkscape_is_sole_desktop_for_document(*desktop)) { SPDocument *doc = desktop->doc(); - if (sp_document_repr_root(doc)->attribute("sodipodi:modified") != NULL) { + if (doc->isModifiedSinceSave()) { GtkWidget *dialog; - dialog = gtk_message_dialog_new( + /** \todo + * FIXME !!! obviously this will have problems if the document + * name contains markup characters + */ + dialog = gtk_message_dialog_new_with_markup( GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(this))), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, - "Document modified"); - - gchar *markup; - /** \todo - * FIXME !!! obviously this will have problems if the document - * name contains markup characters - */ - markup = g_strdup_printf( _("Save changes to document \"%s\" before closing?\n\n" "If you close without saving, your changes will be discarded."), SP_DOCUMENT_NAME(doc)); - - /** \todo - * FIXME !!! Gtk 2.3+ gives us gtk_message_dialog_set_markup() - * (and actually even - * gtk_message_dialog_new_with_markup(..., format, ...)!) -- - * until then, we will have to be a little bit evil here and - * poke at GtkMessageDialog::label, which is private... - */ - - gtk_label_set_markup(GTK_LABEL(GTK_MESSAGE_DIALOG(dialog)->label), markup); - g_free(markup); + // fix for bug 1767940: + GTK_WIDGET_UNSET_FLAGS(GTK_WIDGET(GTK_MESSAGE_DIALOG(dialog)->label), GTK_CAN_FOCUS); GtkWidget *close_button; close_button = gtk_button_new_with_mnemonic(_("Close _without saving")); @@ -569,14 +862,19 @@ SPDesktopWidget::shutdown() switch (response) { case GTK_RESPONSE_YES: + { + Gtk::Window *window = (Gtk::Window*)gtk_object_get_data (GTK_OBJECT(this), "window"); + sp_document_ref(doc); - if (sp_file_save_document(doc)) { + if (sp_file_save_document(*window, doc)) { sp_document_unref(doc); } else { // save dialog cancelled or save failed sp_document_unref(doc); return TRUE; } + break; + } case GTK_RESPONSE_NO: break; default: // cancel pressed, or dialog was closed @@ -589,42 +887,32 @@ SPDesktopWidget::shutdown() while (sp_document_repr_root(doc)->attribute("inkscape:dataloss") != NULL && allow_data_loss == FALSE) { GtkWidget *dialog; - dialog = gtk_message_dialog_new( + /** \todo + * FIXME !!! obviously this will have problems if the document + * name contains markup characters + */ + dialog = gtk_message_dialog_new_with_markup( GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(this))), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, - "Document modified"); - - gchar *markup; - /** \todo - * FIXME !!! obviously this will have problems if the document - * name contains markup characters - */ - markup = g_strdup_printf( _("The file \"%s\" was saved with a format (%s) that may cause data loss!\n\n" - "Do you want to save this file in another format?"), + "Do you want to save this file as an Inkscape SVG?"), SP_DOCUMENT_NAME(doc), Inkscape::Extension::db.get(sp_document_repr_root(doc)->attribute("inkscape:output_extension"))->get_name()); - - /** \todo - * FIXME !!! Gtk 2.3+ gives us gtk_message_dialog_set_markup() - * (and actually even - * gtk_message_dialog_new_with_markup(..., format, ...)!) -- - * until then, we will have to be a little bit evil here and - * poke at GtkMessageDialog::label, which is private... - */ - - gtk_label_set_markup(GTK_LABEL(GTK_MESSAGE_DIALOG(dialog)->label), markup); - g_free(markup); + // fix for bug 1767940: + GTK_WIDGET_UNSET_FLAGS(GTK_WIDGET(GTK_MESSAGE_DIALOG(dialog)->label), GTK_CAN_FOCUS); GtkWidget *close_button; close_button = gtk_button_new_with_mnemonic(_("Close _without saving")); gtk_widget_show(close_button); + GtkWidget *save_button; + save_button = gtk_button_new_with_mnemonic(_("_Save as SVG")); + gtk_widget_show(save_button); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), close_button, GTK_RESPONSE_NO); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); - gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, GTK_RESPONSE_YES); + gtk_dialog_add_action_widget(GTK_DIALOG(dialog), save_button, GTK_RESPONSE_YES); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_YES); gint response; @@ -633,14 +921,20 @@ SPDesktopWidget::shutdown() switch (response) { case GTK_RESPONSE_YES: + { sp_document_ref(doc); - if (sp_file_save_dialog(doc)) { + + Gtk::Window *window = (Gtk::Window*)gtk_object_get_data (GTK_OBJECT(this), "window"); + + if (sp_file_save_dialog(*window, doc)) { sp_document_unref(doc); } else { // save dialog cancelled or save failed sp_document_unref(doc); return TRUE; } + break; + } case GTK_RESPONSE_NO: allow_data_loss = TRUE; break; @@ -651,95 +945,154 @@ SPDesktopWidget::shutdown() } } + /* Save window geometry to prefs for use as a default. + * Use depends on setting of "options.savewindowgeometry". + * But we save the info here regardless of the setting. + */ + { + gint full = desktop->is_fullscreen() ? 1 : 0; + gint maxed = desktop->is_maximized() ? 1 : 0; + prefs_set_int_attribute("desktop.geometry", "fullscreen", full); + prefs_set_int_attribute("desktop.geometry", "maximized", maxed); + gint w, h, x, y; + desktop->getWindowGeometry(x, y, w, h); + // Don't save geom for maximized windows. It + // just tells you the current maximized size, which is not + // as useful as whatever value it had previously. + if (!maxed && !full) { + prefs_set_int_attribute("desktop.geometry", "width", w); + prefs_set_int_attribute("desktop.geometry", "height", h); + prefs_set_int_attribute("desktop.geometry", "x", x); + prefs_set_int_attribute("desktop.geometry", "y", y); + } + } + return FALSE; } /** * \pre this->desktop->main != 0 */ -void +void SPDesktopWidget::requestCanvasUpdate() { gtk_widget_queue_draw (GTK_WIDGET (SP_CANVAS_ITEM (this->desktop->main)->canvas)); } -void -SPDesktopWidget::setCoordinateStatus(NR::Point p) +void +SPDesktopWidget::requestCanvasUpdateAndWait() { + requestCanvasUpdate(); + + while (gtk_events_pending()) + gtk_main_iteration_do(FALSE); + +} + +void +SPDesktopWidget::enableInteraction() +{ + g_return_if_fail(_interaction_disabled_counter > 0); + + _interaction_disabled_counter--; + + if (_interaction_disabled_counter == 0) { + gtk_widget_set_sensitive(GTK_WIDGET(this), TRUE); + } +} + +void +SPDesktopWidget::disableInteraction() +{ + if (_interaction_disabled_counter == 0) { + gtk_widget_set_sensitive(GTK_WIDGET(this), FALSE); + } + + _interaction_disabled_counter++; +} + +void +SPDesktopWidget::setCoordinateStatus(Geom::Point p) { gchar *cstr; - cstr=g_strdup_printf("%6.2f", dt2r * p[NR::X]); - gtk_label_set_text (GTK_LABEL (this->coord_status_x), cstr); + cstr = g_strdup_printf("%7.2f ", dt2r * p[Geom::X]); + gtk_label_set_markup( GTK_LABEL(this->coord_status_x), cstr ); g_free(cstr); - cstr=g_strdup_printf("%6.2f", dt2r * p[NR::Y]); - gtk_label_set_text (GTK_LABEL (this->coord_status_y), cstr); + + cstr = g_strdup_printf("%7.2f ", dt2r * p[Geom::Y]); + gtk_label_set_markup( GTK_LABEL(this->coord_status_y), cstr ); g_free(cstr); } void SPDesktopWidget::letZoomGrabFocus() { - if (zoom_status) + if (zoom_status) gtk_widget_grab_focus (zoom_status); } - -void + +void SPDesktopWidget::getWindowGeometry (gint &x, gint &y, gint &w, gint &h) { - GtkWindow *window = GTK_WINDOW (gtk_object_get_data (GTK_OBJECT(this), "window")); + gboolean vis = GTK_WIDGET_VISIBLE (this); + (void)vis; // TODO figure out why it is here but not used. + + Gtk::Window *window = (Gtk::Window*)gtk_object_get_data (GTK_OBJECT(this), "window"); + if (window) { - gtk_window_get_size (window, &w, &h); - gtk_window_get_position (window, &x, &y); + window->get_size (w, h); + window->get_position (x, y); } } void -SPDesktopWidget::setWindowPosition (NR::Point p) +SPDesktopWidget::setWindowPosition (Geom::Point p) { - GtkWindow *window = GTK_WINDOW (gtk_object_get_data (GTK_OBJECT(this), "window")); + Gtk::Window *window = (Gtk::Window*)gtk_object_get_data (GTK_OBJECT(this), "window"); + if (window) { - gtk_window_move (window, gint(round(p[NR::X])), gint(round(p[NR::Y]))); + window->move (gint(round(p[Geom::X])), gint(round(p[Geom::Y]))); } } void SPDesktopWidget::setWindowSize (gint w, gint h) { - GtkWindow *window = GTK_WINDOW (gtk_object_get_data (GTK_OBJECT(this), "window")); + Gtk::Window *window = (Gtk::Window*)gtk_object_get_data (GTK_OBJECT(this), "window"); + if (window) { - gtk_window_set_default_size (window, w, h); - gtk_window_reshow_with_initial_size (window); + window->set_default_size (w, h); + window->reshow_with_initial_size (); } } /** - * \note transientizing does not work on windows; when you minimize a document - * and then open it back, only its transient emerges and you cannot access - * the document window. + * \note transientizing does not work on windows; when you minimize a document + * and then open it back, only its transient emerges and you cannot access + * the document window. The document window must be restored by rightclicking + * the taskbar button and pressing "Restore" */ void SPDesktopWidget::setWindowTransient (void *p, int transient_policy) { -#ifndef WIN32 GtkWindow *w =GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(this))); if (w) { gtk_window_set_transient_for (GTK_WINDOW(p), w); - - /* + + /* * This enables "aggressive" transientization, - * i.e. dialogs always emerging on top when you switch documents. Note - * however that this breaks "click to raise" policy of a window - * manager because the switched-to document will be raised at once + * i.e. dialogs always emerging on top when you switch documents. Note + * however that this breaks "click to raise" policy of a window + * manager because the switched-to document will be raised at once * (so that its transients also could raise) */ if (transient_policy == 2) - + // without this, a transient window not always emerges on top - gtk_window_present (w); + gtk_window_present (w); } -#endif } void @@ -747,7 +1100,7 @@ SPDesktopWidget::presentWindow() { GtkWindow *w =GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(this))); if (w) - gtk_window_present (w); + gtk_window_present (w); } bool @@ -761,7 +1114,7 @@ SPDesktopWidget::warnDialog (gchar* text) GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, - text); + "%s", text); gint response = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); if (response == GTK_RESPONSE_YES) @@ -770,20 +1123,68 @@ SPDesktopWidget::warnDialog (gchar* text) return false; } +void +sp_desktop_widget_iconify(SPDesktopWidget *dtw) +{ + GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(dtw->canvas))); + if (GTK_IS_WINDOW(topw)) { + if (dtw->desktop->is_iconified()) { + gtk_window_deiconify(topw); + } else { + gtk_window_iconify(topw); + } + } +} + +void +sp_desktop_widget_maximize(SPDesktopWidget *dtw) +{ + GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(dtw->canvas))); + if (GTK_IS_WINDOW(topw)) { + if (dtw->desktop->is_maximized()) { + gtk_window_unmaximize(topw); + } else { + // Save geometry to prefs before maximizing so that + // something useful is stored there, because GTK doesn't maintain + // a separate non-maximized size. + if (!dtw->desktop->is_iconified() && !dtw->desktop->is_fullscreen()) + { + gint w, h, x, y; + dtw->getWindowGeometry(x, y, w, h); + prefs_set_int_attribute("desktop.geometry", "width", w); + prefs_set_int_attribute("desktop.geometry", "height", h); + prefs_set_int_attribute("desktop.geometry", "x", x); + prefs_set_int_attribute("desktop.geometry", "y", y); + } + gtk_window_maximize(topw); + } + } +} + void sp_desktop_widget_fullscreen(SPDesktopWidget *dtw) { #ifdef HAVE_GTK_WINDOW_FULLSCREEN GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(dtw->canvas))); if (GTK_IS_WINDOW(topw)) { - if (dtw->desktop->is_fullscreen) { - dtw->desktop->is_fullscreen = FALSE; + if (dtw->desktop->is_fullscreen()) { gtk_window_unfullscreen(topw); - sp_desktop_widget_layout (dtw); + // widget layout is triggered by the resulting window_state_event } else { - dtw->desktop->is_fullscreen = TRUE; + // Save geometry to prefs before maximizing so that + // something useful is stored there, because GTK doesn't maintain + // a separate non-maximized size. + if (!dtw->desktop->is_iconified() && !dtw->desktop->is_maximized()) + { + gint w, h, x, y; + dtw->getWindowGeometry(x, y, w, h); + prefs_set_int_attribute("desktop.geometry", "width", w); + prefs_set_int_attribute("desktop.geometry", "height", h); + prefs_set_int_attribute("desktop.geometry", "x", x); + prefs_set_int_attribute("desktop.geometry", "y", y); + } gtk_window_fullscreen(topw); - sp_desktop_widget_layout (dtw); + // widget layout is triggered by the resulting window_state_event } } #endif /* HAVE_GTK_WINDOW_FULLSCREEN */ @@ -795,7 +1196,7 @@ sp_desktop_widget_fullscreen(SPDesktopWidget *dtw) void sp_desktop_widget_layout (SPDesktopWidget *dtw) { - bool fullscreen = dtw->desktop->is_fullscreen; + bool fullscreen = dtw->desktop->is_fullscreen(); if (prefs_get_int_attribute (fullscreen ? "fullscreen.menu" : "window.menu", "state", 1) == 0) { gtk_widget_hide_all (dtw->menubar); @@ -831,38 +1232,18 @@ sp_desktop_widget_layout (SPDesktopWidget *dtw) if (prefs_get_int_attribute (fullscreen ? "fullscreen.panels" : "window.panels", "state", 1) == 0) { gtk_widget_hide_all( dtw->panels ); - GList* kids = gtk_container_get_children( GTK_CONTAINER( dtw->statusbar ) ); - if ( kids ) - { - GList* last = g_list_last( kids ); - if ( last ) - { - GtkStatusbar* tail = GTK_STATUSBAR( last->data ); - gtk_statusbar_set_has_resize_grip( tail, TRUE ); - } - g_list_free( kids ); - } } else { gtk_widget_show_all( dtw->panels ); - GList* kids = gtk_container_get_children( GTK_CONTAINER( dtw->statusbar ) ); - if ( kids ) - { - GList* last = g_list_last( kids ); - if ( last ) - { - GtkStatusbar* tail = GTK_STATUSBAR( last->data ); - gtk_statusbar_set_has_resize_grip( tail, FALSE ); - } - g_list_free( kids ); - } } if (prefs_get_int_attribute (fullscreen ? "fullscreen.scrollbars" : "window.scrollbars", "state", 1) == 0) { gtk_widget_hide_all (dtw->hscrollbar); gtk_widget_hide_all (dtw->vscrollbar_box); + gtk_widget_hide_all( dtw->cms_adjust ); } else { gtk_widget_show_all (dtw->hscrollbar); gtk_widget_show_all (dtw->vscrollbar_box); + gtk_widget_show_all( dtw->cms_adjust ); } if (prefs_get_int_attribute (fullscreen ? "fullscreen.rulers" : "window.rulers", "state", 1) == 0) { @@ -878,7 +1259,7 @@ void SPDesktopWidget::setToolboxFocusTo (const gchar* label) { gpointer hb = sp_search_by_data_recursive(aux_toolbox, (gpointer) label); - if (hb && GTK_IS_WIDGET(hb)) + if (hb && GTK_IS_WIDGET(hb)) { gtk_widget_grab_focus(GTK_WIDGET(hb)); } @@ -894,12 +1275,34 @@ SPDesktopWidget::setToolboxAdjustmentValue (gchar const *id, double value) } } +void +SPDesktopWidget::setToolboxSelectOneValue (gchar const *id, int value) +{ + gpointer hb = sp_search_by_data_recursive(aux_toolbox, (gpointer) id); + if (hb) { + ege_select_one_action_set_active((EgeSelectOneAction*) hb, value); + } +} + + bool SPDesktopWidget::isToolboxButtonActive (const gchar* id) { - GtkToggleButton *b = (GtkToggleButton *) sp_search_by_data_recursive(aux_toolbox, (gpointer) id); + bool isActive = false; + gpointer thing = sp_search_by_data_recursive(aux_toolbox, (gpointer) id); + if ( !thing ) { + //g_message( "Unable to locate item for {%s}", id ); + } else if ( GTK_IS_TOGGLE_BUTTON(thing) ) { + GtkToggleButton *b = GTK_TOGGLE_BUTTON(thing); + isActive = gtk_toggle_button_get_active( b ) != 0; + } else if ( GTK_IS_TOGGLE_ACTION(thing) ) { + GtkToggleAction* act = GTK_TOGGLE_ACTION(thing); + isActive = gtk_toggle_action_get_active( act ) != 0; + } else { + //g_message( "Item for {%s} is of an unsupported type", id ); + } - return gtk_toggle_button_get_active (b) != 0; + return isActive; } SPViewWidget * @@ -908,7 +1311,8 @@ sp_desktop_widget_new (SPNamedView *namedview) SPDesktopWidget *dtw = (SPDesktopWidget*)gtk_type_new (SP_TYPE_DESKTOP_WIDGET); dtw->dt2r = 1.0 / namedview->doc_units->unittobase; - dtw->ruler_origin = namedview->gridorigin; + + dtw->ruler_origin = Geom::Point(0,0); //namedview->gridorigin; Why was the grid origin used here? dtw->desktop = new SPDesktop(); dtw->stub = new SPDesktopWidget::WidgetStub (dtw); @@ -919,7 +1323,7 @@ sp_desktop_widget_new (SPNamedView *namedview) // Add the shape geometry to libavoid for autorouting connectors. // This needs desktop set for its spacing preferences. init_avoided_shape_geometry(dtw->desktop); - + dtw->selected_style->setDesktop(dtw->desktop); /* Once desktop is set, we can update rulers */ @@ -928,7 +1332,7 @@ sp_desktop_widget_new (SPNamedView *namedview) sp_view_widget_set_view (SP_VIEW_WIDGET (dtw), dtw->desktop); /* Listen on namedview modification */ - g_signal_connect (G_OBJECT (namedview), "modified", G_CALLBACK (sp_desktop_widget_namedview_modified), dtw); + dtw->modified_connection = namedview->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_desktop_widget_namedview_modified), dtw)); dtw->layer_selector->setDesktop(dtw->desktop); @@ -946,37 +1350,64 @@ sp_desktop_widget_new (SPNamedView *namedview) } void -SPDesktopWidget::viewSetPosition (NR::Point p) +SPDesktopWidget::viewSetPosition (Geom::Point p) { - NR::Point const origin = ( p - ruler_origin ); + Geom::Point const origin = ( p - ruler_origin ); /// \todo fixme: - GTK_RULER(hruler)->position = origin[NR::X]; + GTK_RULER(hruler)->position = origin[Geom::X]; gtk_ruler_draw_pos (GTK_RULER (hruler)); - GTK_RULER(vruler)->position = origin[NR::Y]; + GTK_RULER(vruler)->position = origin[Geom::Y]; gtk_ruler_draw_pos (GTK_RULER (vruler)); } void sp_desktop_widget_update_rulers (SPDesktopWidget *dtw) { - NR::Rect const viewbox = dtw->canvas->getViewbox(); + sp_desktop_widget_update_hruler(dtw); + sp_desktop_widget_update_vruler(dtw); +} + +void +sp_desktop_widget_update_hruler (SPDesktopWidget *dtw) +{ + /* The viewbox (in integers) must exactly match the size of SPCanvasbuf's pixel buffer. + * This is important because the former is being used for drawing the ruler, whereas + * the latter is used for drawing e.g. the grids and guides. Only when the viewbox + * coincides with the pixel buffer, everything will line up nicely. + */ + NR::IRect viewbox = dtw->canvas->getViewboxIntegers(); + double const scale = dtw->desktop->current_zoom(); - double s = viewbox.min()[NR::X] / scale - dtw->ruler_origin[NR::X]; - double e = viewbox.max()[NR::X] / scale - dtw->ruler_origin[NR::X]; + double s = viewbox.min()[Geom::X] / scale - dtw->ruler_origin[Geom::X]; + double e = viewbox.max()[Geom::X] / scale - dtw->ruler_origin[Geom::X]; gtk_ruler_set_range(GTK_RULER(dtw->hruler), s, e, GTK_RULER(dtw->hruler)->position, (e - s)); - s = viewbox.min()[NR::Y] / -scale - dtw->ruler_origin[NR::Y]; - e = viewbox.max()[NR::Y] / -scale - dtw->ruler_origin[NR::Y]; +} + +void +sp_desktop_widget_update_vruler (SPDesktopWidget *dtw) +{ + /* The viewbox (in integers) must exactly match the size of SPCanvasbuf's pixel buffer. + * This is important because the former is being used for drawing the ruler, whereas + * the latter is used for drawing e.g. the grids and guides. Only when the viewbox + * coincides with the pixel buffer, everything will line up nicely. + */ + NR::IRect viewbox = dtw->canvas->getViewboxIntegers(); + + double const scale = dtw->desktop->current_zoom(); + double s = viewbox.min()[Geom::Y] / -scale - dtw->ruler_origin[Geom::Y]; + double e = viewbox.max()[Geom::Y] / -scale - dtw->ruler_origin[Geom::Y]; gtk_ruler_set_range(GTK_RULER(dtw->vruler), s, e, GTK_RULER(dtw->vruler)->position, (e - s)); } static void -sp_desktop_widget_namedview_modified (SPNamedView *nv, guint flags, SPDesktopWidget *dtw) +sp_desktop_widget_namedview_modified (SPObject *obj, guint flags, SPDesktopWidget *dtw) { + SPNamedView *nv=SP_NAMEDVIEW(obj); if (flags & SP_OBJECT_MODIFIED_FLAG) { dtw->dt2r = 1.0 / nv->doc_units->unittobase; - dtw->ruler_origin = nv->gridorigin; + dtw->ruler_origin = Geom::Point(0,0); //nv->gridorigin; Why was the grid origin used here? sp_ruler_set_metric (GTK_RULER (dtw->vruler), nv->getDefaultMetric()); sp_ruler_set_metric (GTK_RULER (dtw->hruler), nv->getDefaultMetric()); @@ -989,7 +1420,7 @@ sp_desktop_widget_namedview_modified (SPNamedView *nv, guint flags, SPDesktopWid } static void -sp_desktop_widget_adjustment_value_changed (GtkAdjustment *adj, SPDesktopWidget *dtw) +sp_desktop_widget_adjustment_value_changed (GtkAdjustment */*adj*/, SPDesktopWidget *dtw) { if (dtw->update) return; @@ -999,26 +1430,33 @@ sp_desktop_widget_adjustment_value_changed (GtkAdjustment *adj, SPDesktopWidget sp_canvas_scroll_to (dtw->canvas, dtw->hadj->value, dtw->vadj->value, FALSE); sp_desktop_widget_update_rulers (dtw); + /* update perspective lines if we are in the 3D box tool (so that infinite ones are shown correctly) */ + sp_box3d_context_update_lines(dtw->desktop->event_context); + dtw->update = 0; } /* we make the desktop window with focus active, signal is connected in interface.c */ - -gint -sp_desktop_widget_set_focus (GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw) +bool SPDesktopWidget::onFocusInEvent(GdkEventFocus*) { - inkscape_activate_desktop (dtw->desktop); - /* give focus to canvas widget */ - gtk_widget_grab_focus (GTK_WIDGET (dtw->canvas)); + if (prefs_get_int_attribute_limited("options.bitmapautoreload", "value", 1, 0, 1)) { + GSList const *imageList = sp_document_get_resource_list(desktop->doc(), "image"); + for (GSList const *p = imageList; p; p = p->next) { + SPImage* image = SP_IMAGE(p->data); + sp_image_refresh_if_outdated( image ); + } + } - return FALSE; + inkscape_activate_desktop (desktop); + + return false; } static gdouble sp_dtw_zoom_value_to_display (gdouble value) { - return floor (pow (2, value) * 100.0 + 0.5); + return floor (10 * (pow (2, value) * 100.0 + 0.05)) / 10; } static gdouble @@ -1028,7 +1466,7 @@ sp_dtw_zoom_display_to_value (gdouble value) } static gint -sp_dtw_zoom_input (GtkSpinButton *spin, gdouble *new_val, gpointer data) +sp_dtw_zoom_input (GtkSpinButton *spin, gdouble *new_val, gpointer /*data*/) { gdouble new_scrolled = gtk_spin_button_get_value (spin); const gchar *b = gtk_entry_get_text (GTK_ENTRY (spin)); @@ -1044,10 +1482,15 @@ sp_dtw_zoom_input (GtkSpinButton *spin, gdouble *new_val, gpointer data) } static bool -sp_dtw_zoom_output (GtkSpinButton *spin, gpointer data) +sp_dtw_zoom_output (GtkSpinButton *spin, gpointer /*data*/) { gchar b[64]; - g_snprintf (b, 64, "%4.0f%%", sp_dtw_zoom_value_to_display (gtk_spin_button_get_value (spin))); + double val = sp_dtw_zoom_value_to_display (gtk_spin_button_get_value (spin)); + if (val < 10) { + g_snprintf (b, 64, "%4.1f%%", val); + } else { + g_snprintf (b, 64, "%4.0f%%", val); + } gtk_entry_set_text (GTK_ENTRY (spin), b); return TRUE; } @@ -1060,16 +1503,16 @@ sp_dtw_zoom_value_changed (GtkSpinButton *spin, gpointer data) SPDesktopWidget *dtw = SP_DESKTOP_WIDGET (data); SPDesktop *desktop = dtw->desktop; - NR::Rect const d = desktop->get_display_area(); + Geom::Rect const d = to_2geom(desktop->get_display_area()); g_signal_handler_block (spin, dtw->zoom_update); - desktop->zoom_absolute (d.midpoint()[NR::X], d.midpoint()[NR::Y], zoom_factor); + desktop->zoom_absolute (d.midpoint()[Geom::X], d.midpoint()[Geom::Y], zoom_factor); g_signal_handler_unblock (spin, dtw->zoom_update); spinbutton_defocus (GTK_OBJECT (spin)); } static void -sp_dtw_zoom_populate_popup (GtkEntry *entry, GtkMenu *menu, gpointer data) +sp_dtw_zoom_populate_popup (GtkEntry */*entry*/, GtkMenu *menu, gpointer data) { GList *children, *iter; GtkWidget *item; @@ -1115,42 +1558,42 @@ sp_dtw_zoom_populate_popup (GtkEntry *entry, GtkMenu *menu, gpointer data) static void sp_dtw_zoom_menu_handler (SPDesktop *dt, gdouble factor) { - NR::Rect const d = dt->get_display_area(); - dt->zoom_absolute(d.midpoint()[NR::X], d.midpoint()[NR::Y], factor); + Geom::Rect const d = to_2geom(dt->get_display_area()); + dt->zoom_absolute(d.midpoint()[Geom::X], d.midpoint()[Geom::Y], factor); } static void -sp_dtw_zoom_50 (GtkMenuItem *item, gpointer data) +sp_dtw_zoom_50 (GtkMenuItem */*item*/, gpointer data) { sp_dtw_zoom_menu_handler (static_cast(data), 0.5); } static void -sp_dtw_zoom_100 (GtkMenuItem *item, gpointer data) +sp_dtw_zoom_100 (GtkMenuItem */*item*/, gpointer data) { sp_dtw_zoom_menu_handler (static_cast(data), 1.0); } static void -sp_dtw_zoom_200 (GtkMenuItem *item, gpointer data) +sp_dtw_zoom_200 (GtkMenuItem */*item*/, gpointer data) { sp_dtw_zoom_menu_handler (static_cast(data), 2.0); } static void -sp_dtw_zoom_page (GtkMenuItem *item, gpointer data) +sp_dtw_zoom_page (GtkMenuItem */*item*/, gpointer data) { static_cast(data)->zoom_page(); } static void -sp_dtw_zoom_drawing (GtkMenuItem *item, gpointer data) +sp_dtw_zoom_drawing (GtkMenuItem */*item*/, gpointer data) { static_cast(data)->zoom_drawing(); } static void -sp_dtw_zoom_selection (GtkMenuItem *item, gpointer data) +sp_dtw_zoom_selection (GtkMenuItem */*item*/, gpointer data) { static_cast(data)->zoom_selection(); } @@ -1162,6 +1605,9 @@ sp_desktop_widget_update_zoom (SPDesktopWidget *dtw) { g_signal_handlers_block_by_func (G_OBJECT (dtw->zoom_status), (gpointer)G_CALLBACK (sp_dtw_zoom_value_changed), dtw); gtk_spin_button_set_value (GTK_SPIN_BUTTON (dtw->zoom_status), log(dtw->desktop->current_zoom()) / log(2)); + gtk_widget_queue_draw(GTK_WIDGET(dtw->zoom_status)); + if (GTK_WIDGET(dtw->zoom_status)->window) + gdk_window_process_updates(GTK_WIDGET(dtw->zoom_status)->window, TRUE); g_signal_handlers_unblock_by_func (G_OBJECT (dtw->zoom_status), (gpointer)G_CALLBACK (sp_dtw_zoom_value_changed), dtw); } @@ -1171,11 +1617,11 @@ sp_desktop_widget_toggle_rulers (SPDesktopWidget *dtw) if (GTK_WIDGET_VISIBLE (dtw->hruler)) { gtk_widget_hide_all (dtw->hruler); gtk_widget_hide_all (dtw->vruler); - prefs_set_int_attribute (dtw->desktop->is_fullscreen ? "fullscreen.rulers" : "window.rulers", "state", 0); + prefs_set_int_attribute (dtw->desktop->is_fullscreen() ? "fullscreen.rulers" : "window.rulers", "state", 0); } else { gtk_widget_show_all (dtw->hruler); gtk_widget_show_all (dtw->vruler); - prefs_set_int_attribute (dtw->desktop->is_fullscreen ? "fullscreen.rulers" : "window.rulers", "state", 1); + prefs_set_int_attribute (dtw->desktop->is_fullscreen() ? "fullscreen.rulers" : "window.rulers", "state", 1); } } @@ -1185,11 +1631,25 @@ sp_desktop_widget_toggle_scrollbars (SPDesktopWidget *dtw) if (GTK_WIDGET_VISIBLE (dtw->hscrollbar)) { gtk_widget_hide_all (dtw->hscrollbar); gtk_widget_hide_all (dtw->vscrollbar_box); - prefs_set_int_attribute (dtw->desktop->is_fullscreen ? "fullscreen.scrollbars" : "window.scrollbars", "state", 0); + gtk_widget_hide_all( dtw->cms_adjust ); + prefs_set_int_attribute (dtw->desktop->is_fullscreen() ? "fullscreen.scrollbars" : "window.scrollbars", "state", 0); } else { gtk_widget_show_all (dtw->hscrollbar); gtk_widget_show_all (dtw->vscrollbar_box); - prefs_set_int_attribute (dtw->desktop->is_fullscreen ? "fullscreen.scrollbars" : "window.scrollbars", "state", 1); + gtk_widget_show_all( dtw->cms_adjust ); + prefs_set_int_attribute (dtw->desktop->is_fullscreen() ? "fullscreen.scrollbars" : "window.scrollbars", "state", 1); + } +} + +void sp_desktop_widget_toggle_color_prof_adj( SPDesktopWidget *dtw ) +{ + + if ( GTK_WIDGET_SENSITIVE( dtw->cms_adjust ) ) { + if ( SP_BUTTON_IS_DOWN(dtw->cms_adjust) ) { + sp_button_toggle_set_down( SP_BUTTON(dtw->cms_adjust), FALSE ); + } else { + sp_button_toggle_set_down( SP_BUTTON(dtw->cms_adjust), TRUE ); + } } } @@ -1233,34 +1693,32 @@ sp_desktop_widget_update_scrollbars (SPDesktopWidget *dtw, double scale) /* The desktop region we always show unconditionally */ SPDocument *doc = dtw->desktop->doc(); - NR::Rect const r = sp_item_bbox_desktop(SP_ITEM(SP_DOCUMENT_ROOT(doc))); - NR::Rect darea(NR::Point(MIN(r.min()[NR::X], -sp_document_width(doc)), - MIN(r.min()[NR::Y], -sp_document_height(doc))), - NR::Point(MAX(r.max()[NR::X], 2 * sp_document_width(doc)), - MAX(r.max()[NR::Y], 2 * sp_document_height(doc)))); + NR::Rect darea(Geom::Point(-sp_document_width(doc), -sp_document_height(doc)), + Geom::Point(2 * sp_document_width(doc), 2 * sp_document_height(doc))); + darea = NR::union_bounds(darea, sp_item_bbox_desktop(SP_ITEM(SP_DOCUMENT_ROOT(doc)))); /* Canvas region we always show unconditionally */ - NR::Rect carea(NR::Point(darea.min()[NR::X] * scale - 64, - darea.max()[NR::Y] * -scale - 64), - NR::Point(darea.max()[NR::X] * scale + 64, - darea.min()[NR::Y] * -scale + 64)); + NR::Rect carea(Geom::Point(darea.min()[Geom::X] * scale - 64, + darea.max()[Geom::Y] * -scale - 64), + Geom::Point(darea.max()[Geom::X] * scale + 64, + darea.min()[Geom::Y] * -scale + 64)); NR::Rect viewbox = dtw->canvas->getViewbox(); /* Viewbox is always included into scrollable region */ - carea = NR::Rect::union_bounds(carea, viewbox); - - set_adjustment(dtw->hadj, carea.min()[NR::X], carea.max()[NR::X], - viewbox.dimensions()[NR::X], - 0.1 * viewbox.dimensions()[NR::X], - viewbox.dimensions()[NR::X]); - gtk_adjustment_set_value(dtw->hadj, viewbox.min()[NR::X]); - - set_adjustment(dtw->vadj, carea.min()[NR::Y], carea.max()[NR::Y], - viewbox.dimensions()[NR::Y], - 0.1 * viewbox.dimensions()[NR::Y], - viewbox.dimensions()[NR::Y]); - gtk_adjustment_set_value(dtw->vadj, viewbox.min()[NR::Y]); + carea = NR::union_bounds(carea, viewbox); + + set_adjustment(dtw->hadj, carea.min()[Geom::X], carea.max()[Geom::X], + viewbox.dimensions()[Geom::X], + 0.1 * viewbox.dimensions()[Geom::X], + viewbox.dimensions()[Geom::X]); + gtk_adjustment_set_value(dtw->hadj, viewbox.min()[Geom::X]); + + set_adjustment(dtw->vadj, carea.min()[Geom::Y], carea.max()[Geom::Y], + viewbox.dimensions()[Geom::Y], + 0.1 * viewbox.dimensions()[Geom::Y], + viewbox.dimensions()[Geom::Y]); + gtk_adjustment_set_value(dtw->vadj, viewbox.min()[Geom::Y]); dtw->update = 0; }