X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fwidgets%2Fdesktop-widget.cpp;h=5396ecc24f6ba9155486811648ddad9d21e2fc3c;hb=396d5aa732c14fad8d67a143132eb232a45dd7f2;hp=cc723a532dacdbb9f5e34d78fff40f39ccf70229;hpb=d06ae096dd19d2eb6ff180c4a036f38bf5d9cbeb;p=inkscape.git diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp index cc723a532..5396ecc24 100644 --- a/src/widgets/desktop-widget.cpp +++ b/src/widgets/desktop-widget.cpp @@ -37,6 +37,7 @@ #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" @@ -48,10 +49,16 @@ #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" #if defined (SOLARIS_2_8) #include "round.h" @@ -84,8 +91,9 @@ 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 (SPObject *obj, guint flags, SPDesktopWidget *dtw); @@ -105,6 +113,107 @@ static void sp_dtw_zoom_selection (GtkMenuItem *item, gpointer data); SPViewWidgetClass *dtw_parent_class; +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*/) +{ + 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 ); +} + +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; + (void)new_value; +#endif // ENABLE_LCMS + } +} + +static PrefWatcher* watcher = 0; + void SPDesktopWidget::setMessage (Inkscape::MessageType type, const gchar *message) { @@ -117,8 +226,7 @@ SPDesktopWidget::setMessage (Inkscape::MessageType type, const gchar *message) gdk_window_process_updates(GTK_WIDGET(sb)->window, TRUE); } - // FIXME: TODO: remove before displaying as tooltip - gtk_tooltips_set_tip (this->tt, this->select_status_eventbox, message ? message : "", NULL); + gtk_tooltips_set_tip (this->tt, this->select_status_eventbox, gtk_label_get_text (sb) , NULL); } NR::Point @@ -175,6 +283,7 @@ sp_desktop_widget_init (SPDesktopWidget *dtw) { GtkWidget *widget; GtkWidget *tbl; + GtkWidget *canvas_tbl; GtkWidget *hbox; GtkWidget *eventbox; @@ -222,9 +331,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 (); @@ -232,7 +343,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); @@ -244,7 +355,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); @@ -252,7 +363,8 @@ 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 ( Inkscape::ICON_SIZE_DECORATION, @@ -266,17 +378,91 @@ 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 */ 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); g_signal_connect (G_OBJECT (dtw->canvas), "event", G_CALLBACK (sp_desktop_widget_event), dtw); - gtk_table_attach (GTK_TABLE (tbl), GTK_WIDGET (dtw->canvas), 1, 2, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); + 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(); @@ -339,6 +525,18 @@ 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())); + { + 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 ); + } + 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 @@ -365,6 +563,9 @@ 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); @@ -397,7 +598,8 @@ sp_desktop_widget_destroy (GtkObject *object) 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 @@ -416,11 +618,17 @@ SPDesktopWidget::updateTitle(gchar const* uri) 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. */ @@ -533,14 +741,54 @@ sp_desktop_widget_event (GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dt return FALSE; } +void sp_dtw_color_profile_event(EgeColorProfTracker */*tracker*/, SPDesktopWidget *dtw) +{ + // 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 ); +} + +void cms_adjust_toggled( GtkWidget */*button*/, gpointer data ) +{ + 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 ); + } +} + +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 */ } @@ -555,38 +803,26 @@ 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) { GtkWidget *dialog; - dialog = gtk_message_dialog_new( - 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( + 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, _("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")); @@ -603,14 +839,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 @@ -623,42 +864,32 @@ SPDesktopWidget::shutdown() while (sp_document_repr_root(doc)->attribute("inkscape:dataloss") != NULL && allow_data_loss == FALSE) { GtkWidget *dialog; - dialog = gtk_message_dialog_new( - 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( + 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, _("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; @@ -667,14 +898,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; @@ -685,6 +922,28 @@ 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; } @@ -750,32 +1009,38 @@ SPDesktopWidget::letZoomGrabFocus() 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) { - 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[NR::X])), gint(round(p[NR::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 (); } } @@ -835,20 +1100,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 */ @@ -860,7 +1173,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); @@ -903,9 +1216,11 @@ sp_desktop_widget_layout (SPDesktopWidget *dtw) 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) { @@ -937,6 +1252,16 @@ 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) { @@ -963,7 +1288,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 = NR::Point(0,0); //namedview->gridorigin; Why was the grid origin used here? dtw->desktop = new SPDesktop(); dtw->stub = new SPDesktopWidget::WidgetStub (dtw); @@ -1032,7 +1358,7 @@ sp_desktop_widget_namedview_modified (SPObject *obj, guint flags, SPDesktopWidge 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 = NR::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()); @@ -1045,7 +1371,7 @@ sp_desktop_widget_namedview_modified (SPObject *obj, guint flags, SPDesktopWidge } 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; @@ -1059,22 +1385,17 @@ sp_desktop_widget_adjustment_value_changed (GtkAdjustment *adj, SPDesktopWidget } /* 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); + inkscape_activate_desktop (desktop); - /* give focus to canvas widget */ - gtk_widget_grab_focus (GTK_WIDGET (dtw->canvas)); - - return FALSE; + 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 @@ -1084,7 +1405,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)); @@ -1100,10 +1421,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; } @@ -1125,7 +1451,7 @@ sp_dtw_zoom_value_changed (GtkSpinButton *spin, gpointer data) } 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; @@ -1176,37 +1502,37 @@ sp_dtw_zoom_menu_handler (SPDesktop *dt, gdouble 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(); } @@ -1218,6 +1544,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); } @@ -1227,11 +1556,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); } } @@ -1241,11 +1570,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 ); + } } }