X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fsp-namedview.cpp;h=47720c5d64f12fb9409e1f74aa7a537b457d0fe8;hb=11c5de79de3c200331e168a745b0505a50aeffea;hp=4dfdb1b282945fea93f2dd213e0a750c3191d87e;hpb=91ff754f4da47efc8f558ea87cfcf92f86934944;p=inkscape.git diff --git a/src/sp-namedview.cpp b/src/sp-namedview.cpp index 4dfdb1b28..47720c5d6 100644 --- a/src/sp-namedview.cpp +++ b/src/sp-namedview.cpp @@ -7,18 +7,19 @@ * Lauris Kaplinski * bulia byak * - * Copyright (C) 1999-2005 Authors + * Copyright (C) 2006 Johan Engelen + * Copyright (C) 1999-2008 Authors * Copyright (C) 2000-2001 Ximian, Inc. * * Released under GNU GPL, read the file 'COPYING' for more information */ #include "config.h" - - - +#include +#include #include "display/canvas-grid.h" +#include "display/guideline.h" #include "helper/units.h" #include "svg/svg-color.h" #include "xml/repr.h" @@ -26,16 +27,14 @@ #include "document.h" #include "desktop-events.h" #include "desktop-handles.h" +#include "event-log.h" #include "sp-guide.h" #include "sp-item-group.h" #include "sp-namedview.h" -#include "prefs-utils.h" +#include "preferences.h" #include "desktop.h" #include "conn-avoid-ref.h" // for defaultConnSpacing. -#include "isnan.h" //temp fix for isnan(). include last - -#define DEFAULTTOLERANCE 0.4 #define DEFAULTGRIDCOLOR 0x3f3fff25 #define DEFAULTGRIDEMPCOLOR 0x3f3fff60 #define DEFAULTGRIDEMPSPACING 5 @@ -52,15 +51,12 @@ static void sp_namedview_release(SPObject *object); static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *value); static void sp_namedview_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref); static void sp_namedview_remove_child(SPObject *object, Inkscape::XML::Node *child); -static Inkscape::XML::Node *sp_namedview_write(SPObject *object, Inkscape::XML::Node *repr, guint flags); +static Inkscape::XML::Node *sp_namedview_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags); static void sp_namedview_setup_guides(SPNamedView * nv); - -static void sp_namedview_setup_grid(SPNamedView * nv); -static void sp_namedview_setup_grid_item(SPNamedView * nv, SPCanvasItem * item); +static void sp_namedview_show_single_guide(SPGuide* guide, bool show); static gboolean sp_str_to_bool(const gchar *str); -static gboolean sp_nv_read_length(const gchar *str, guint base, gdouble *val, const SPUnit **unit); static gboolean sp_nv_read_opacity(const gchar *str, guint32 *color); static SPObjectGroupClass * parent_class; @@ -72,15 +68,15 @@ sp_namedview_get_type() if (!namedview_type) { GTypeInfo namedview_info = { sizeof(SPNamedViewClass), - NULL, /* base_init */ - NULL, /* base_finalize */ + NULL, /* base_init */ + NULL, /* base_finalize */ (GClassInitFunc) sp_namedview_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ + NULL, /* class_finalize */ + NULL, /* class_data */ sizeof(SPNamedView), - 16, /* n_preallocs */ + 16, /* n_preallocs */ (GInstanceInitFunc) sp_namedview_init, - NULL, /* value_table */ + NULL, /* value_table */ }; namedview_type = g_type_register_static(SP_TYPE_OBJECTGROUP, "SPNamedView", &namedview_info, (GTypeFlags)0); } @@ -108,21 +104,108 @@ static void sp_namedview_class_init(SPNamedViewClass * klass) static void sp_namedview_init(SPNamedView *nv) { nv->editable = TRUE; - nv->showgrid = FALSE; nv->showguides = TRUE; + nv->grids_visible = false; nv->showborder = TRUE; nv->showpageshadow = TRUE; nv->guides = NULL; nv->viewcount = 0; + nv->grids = NULL; nv->default_layer_id = 0; nv->connector_spacing = defaultConnSpacing; - new (&nv->grid_snapper) Inkscape::GridSnapper(nv, 0); - new (&nv->guide_snapper) Inkscape::GuideSnapper(nv, 0); - new (&nv->object_snapper) Inkscape::ObjectSnapper(nv, 0); + new (&nv->snap_manager) SnapManager(nv); +} + +static void sp_namedview_generate_old_grid(SPNamedView * /*nv*/, SPDocument *document, Inkscape::XML::Node *repr) { + bool old_grid_settings_present = false; + + // set old settings + const char* gridspacingx = "1px"; + const char* gridspacingy = "1px"; + const char* gridoriginy = "0px"; + const char* gridoriginx = "0px"; + const char* gridempspacing = "5"; + const char* gridcolor = "#0000ff"; + const char* gridempcolor = "#0000ff"; + const char* gridopacity = "0.2"; + const char* gridempopacity = "0.4"; + + const char* value = NULL; + if ((value = repr->attribute("gridoriginx"))) { + gridspacingx = value; + old_grid_settings_present = true; + } + if ((value = repr->attribute("gridoriginy"))) { + gridoriginy = value; + old_grid_settings_present = true; + } + if ((value = repr->attribute("gridspacingx"))) { + gridspacingx = value; + old_grid_settings_present = true; + } + if ((value = repr->attribute("gridspacingy"))) { + gridspacingy = value; + old_grid_settings_present = true; + } + if ((value = repr->attribute("gridcolor"))) { + gridcolor = value; + old_grid_settings_present = true; + } + if ((value = repr->attribute("gridempcolor"))) { + gridempcolor = value; + old_grid_settings_present = true; + } + if ((value = repr->attribute("gridempspacing"))) { + gridempspacing = value; + old_grid_settings_present = true; + } + if ((value = repr->attribute("gridopacity"))) { + gridopacity = value; + old_grid_settings_present = true; + } + if ((value = repr->attribute("gridempopacity"))) { + gridempopacity = value; + old_grid_settings_present = true; + } + + if (old_grid_settings_present) { + // generate new xy grid with the correct settings + // first create the child xml node, then hook it to repr. This order is important, to not set off listeners to repr before the new node is complete. + + Inkscape::XML::Document *xml_doc = sp_document_repr_doc(document); + Inkscape::XML::Node *newnode = xml_doc->createElement("inkscape:grid"); + newnode->setAttribute("id", "GridFromPre046Settings"); + newnode->setAttribute("type", Inkscape::CanvasGrid::getSVGName(Inkscape::GRID_RECTANGULAR)); + newnode->setAttribute("originx", gridoriginx); + newnode->setAttribute("originy", gridoriginy); + newnode->setAttribute("spacingx", gridspacingx); + newnode->setAttribute("spacingy", gridspacingy); + newnode->setAttribute("color", gridcolor); + newnode->setAttribute("empcolor", gridempcolor); + newnode->setAttribute("opacity", gridopacity); + newnode->setAttribute("empopacity", gridempopacity); + newnode->setAttribute("empspacing", gridempspacing); + + repr->appendChild(newnode); + Inkscape::GC::release(newnode); + + // remove all old settings + repr->setAttribute("gridoriginx", NULL); + repr->setAttribute("gridoriginy", NULL); + repr->setAttribute("gridspacingx", NULL); + repr->setAttribute("gridspacingy", NULL); + repr->setAttribute("gridcolor", NULL); + repr->setAttribute("gridempcolor", NULL); + repr->setAttribute("gridopacity", NULL); + repr->setAttribute("gridempopacity", NULL); + repr->setAttribute("gridempspacing", NULL); + +// sp_document_done(doc, SP_VERB_DIALOG_NAMEDVIEW, _("Create new grid from pre0.46 grid settings")); + } } static void sp_namedview_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr) @@ -136,21 +219,11 @@ static void sp_namedview_build(SPObject *object, SPDocument *document, Inkscape: sp_object_read_attr(object, "inkscape:document-units"); sp_object_read_attr(object, "viewonly"); - sp_object_read_attr(object, "showgrid"); sp_object_read_attr(object, "showguides"); + sp_object_read_attr(object, "showgrid"); sp_object_read_attr(object, "gridtolerance"); sp_object_read_attr(object, "guidetolerance"); sp_object_read_attr(object, "objecttolerance"); - sp_object_read_attr(object, "inkscape:has_abs_tolerance"); - sp_object_read_attr(object, "gridoriginx"); - sp_object_read_attr(object, "gridoriginy"); - sp_object_read_attr(object, "gridspacingx"); - sp_object_read_attr(object, "gridspacingy"); - sp_object_read_attr(object, "gridempspacing"); - sp_object_read_attr(object, "gridcolor"); - sp_object_read_attr(object, "gridempcolor"); - sp_object_read_attr(object, "gridopacity"); - sp_object_read_attr(object, "gridempopacity"); sp_object_read_attr(object, "guidecolor"); sp_object_read_attr(object, "guideopacity"); sp_object_read_attr(object, "guidehicolor"); @@ -170,19 +243,29 @@ static void sp_namedview_build(SPObject *object, SPDocument *document, Inkscape: sp_object_read_attr(object, "inkscape:window-height"); sp_object_read_attr(object, "inkscape:window-x"); sp_object_read_attr(object, "inkscape:window-y"); - sp_object_read_attr(object, "inkscape:grid-bbox"); - sp_object_read_attr(object, "inkscape:guide-bbox"); - sp_object_read_attr(object, "inkscape:object-bbox"); - sp_object_read_attr(object, "inkscape:grid-points"); - sp_object_read_attr(object, "inkscape:guide-points"); - sp_object_read_attr(object, "inkscape:object-points"); + sp_object_read_attr(object, "inkscape:window-maximized"); + sp_object_read_attr(object, "inkscape:snap-global"); + sp_object_read_attr(object, "inkscape:snap-bbox"); + sp_object_read_attr(object, "inkscape:snap-nodes"); + sp_object_read_attr(object, "inkscape:snap-from-guide"); + sp_object_read_attr(object, "inkscape:snap-center"); + sp_object_read_attr(object, "inkscape:snap-smooth-nodes"); + sp_object_read_attr(object, "inkscape:snap-midpoints"); + sp_object_read_attr(object, "inkscape:snap-object-midpoints"); + sp_object_read_attr(object, "inkscape:snap-bbox-edge-midpoints"); + sp_object_read_attr(object, "inkscape:snap-bbox-midpoints"); + sp_object_read_attr(object, "inkscape:snap-to-guides"); + sp_object_read_attr(object, "inkscape:snap-grids"); + sp_object_read_attr(object, "inkscape:snap-intersection-paths"); sp_object_read_attr(object, "inkscape:object-paths"); sp_object_read_attr(object, "inkscape:object-nodes"); + sp_object_read_attr(object, "inkscape:bbox-paths"); + sp_object_read_attr(object, "inkscape:bbox-nodes"); + sp_object_read_attr(object, "inkscape:snap-page"); sp_object_read_attr(object, "inkscape:current-layer"); sp_object_read_attr(object, "inkscape:connector-spacing"); /* Construct guideline list */ - for (SPObject *o = sp_object_first_child(SP_OBJECT(og)) ; o != NULL; o = SP_OBJECT_NEXT(o) ) { if (SP_IS_GUIDE(o)) { SPGuide * g = SP_GUIDE(o); @@ -190,6 +273,9 @@ static void sp_namedview_build(SPObject *object, SPDocument *document, Inkscape: g_object_set(G_OBJECT(g), "color", nv->guidecolor, "hicolor", nv->guidehicolor, NULL); } } + + // backwards compatibility with grid settings (pre 0.46) + sp_namedview_generate_old_grid(nv, document, repr); } static void sp_namedview_release(SPObject *object) @@ -201,18 +287,18 @@ static void sp_namedview_release(SPObject *object) namedview->guides = NULL; } - while (namedview->gridviews) { - gtk_object_unref(GTK_OBJECT(namedview->gridviews->data)); - namedview->gridviews = g_slist_remove(namedview->gridviews, namedview->gridviews->data); + // delete grids: + while ( namedview->grids ) { + Inkscape::CanvasGrid *gr = (Inkscape::CanvasGrid *)namedview->grids->data; // get first entry + delete gr; + namedview->grids = g_slist_remove_link(namedview->grids, namedview->grids); // deletes first entry } - namedview->grid_snapper.~GridSnapper(); - namedview->guide_snapper.~GuideSnapper(); - namedview->object_snapper.~ObjectSnapper(); - if (((SPObjectClass *) parent_class)->release) { ((SPObjectClass *) parent_class)->release(object); } + + namedview->snap_manager.~SnapManager(); } static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *value) @@ -221,133 +307,40 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va SPUnit const &px = sp_unit_get_by_id(SP_UNIT_PX); switch (key) { - case SP_ATTR_VIEWONLY: + case SP_ATTR_VIEWONLY: nv->editable = (!value); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_SHOWGRID: - nv->showgrid = sp_str_to_bool(value); - sp_namedview_setup_grid(nv); - if (!nv->showgrid) { // grid goes off, disable snaps even if they are turned on - nv->grid_snapper.setSnapTo(Inkscape::Snapper::BBOX_POINT, false); - nv->grid_snapper.setSnapTo(Inkscape::Snapper::SNAP_POINT, false); - } else { // grid goes on, enable snaps if they are turned on - nv->grid_snapper.setSnapTo(Inkscape::Snapper::BBOX_POINT, nv->snap_grid_bbox); - nv->grid_snapper.setSnapTo(Inkscape::Snapper::SNAP_POINT, nv->snap_grid_point); - } - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - case SP_ATTR_SHOWGUIDES: + case SP_ATTR_SHOWGUIDES: if (!value) { // show guides if not specified, for backwards compatibility nv->showguides = TRUE; } else { nv->showguides = sp_str_to_bool(value); } - if (!nv->showguides) { // guides go off, disable snaps even if they are turned on - nv->guide_snapper.setSnapTo(Inkscape::Snapper::BBOX_POINT, false); - nv->guide_snapper.setSnapTo(Inkscape::Snapper::SNAP_POINT, false); - } else { // guides go on, enable snaps if they are turned on - nv->guide_snapper.setSnapTo(Inkscape::Snapper::BBOX_POINT, nv->snap_guide_bbox); - nv->guide_snapper.setSnapTo(Inkscape::Snapper::SNAP_POINT, nv->snap_guide_point); - } sp_namedview_setup_guides(nv); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_GRIDTOLERANCE: - nv->gridtoleranceunit = &px; - nv->gridtolerance = DEFAULTTOLERANCE; - if (value) { - sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &nv->gridtolerance, &nv->gridtoleranceunit); - } - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - case SP_ATTR_GUIDETOLERANCE: - nv->guidetoleranceunit = &px; - nv->guidetolerance = DEFAULTTOLERANCE; - if (value) { - sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &nv->guidetolerance, &nv->guidetoleranceunit); - } - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - case SP_ATTR_OBJECTTOLERANCE: - nv->objecttoleranceunit = &px; - nv->objecttolerance = DEFAULTTOLERANCE; - if (value) { - sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &nv->objecttolerance, &nv->objecttoleranceunit); - } - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - case SP_ATTR_ABS_TOLERANCE: - if (!value) - nv->has_abs_tolerance = true; - else - nv->has_abs_tolerance = (sp_str_to_bool (value) == TRUE); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - case SP_ATTR_GRIDORIGINX: - case SP_ATTR_GRIDORIGINY: - { - unsigned const d = (key == SP_ATTR_GRIDORIGINY); - nv->gridunit = nv->doc_units; - nv->gridorigin[d] = 0.0; - if (value) { - sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &nv->gridorigin[d], &nv->gridunit); - } - nv->gridorigin[d] = sp_units_get_pixels(nv->gridorigin[d], *(nv->gridunit)); - sp_namedview_setup_grid(nv); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - } - case SP_ATTR_GRIDSPACINGX: - case SP_ATTR_GRIDSPACINGY: - { - unsigned const d = (key == SP_ATTR_GRIDSPACINGY); - nv->gridunit = nv->doc_units; - nv->gridspacing[d] = 1.0; - if (value) { - sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &nv->gridspacing[d], &nv->gridunit); - } - nv->gridspacing[d] = sp_units_get_pixels(nv->gridspacing[d], *(nv->gridunit)); - sp_namedview_setup_grid(nv); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - } - case SP_ATTR_GRIDCOLOR: - nv->gridcolor = (nv->gridcolor & 0xff) | (DEFAULTGRIDCOLOR & 0xffffff00); - if (value) { - nv->gridcolor = (nv->gridcolor & 0xff) | sp_svg_read_color(value, nv->gridcolor); - } - sp_namedview_setup_grid(nv); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - case SP_ATTR_GRIDEMPCOLOR: - nv->gridempcolor = (nv->gridempcolor & 0xff) | (DEFAULTGRIDEMPCOLOR & 0xffffff00); - if (value) { - nv->gridempcolor = (nv->gridempcolor & 0xff) | sp_svg_read_color(value, nv->gridempcolor); + case SP_ATTR_SHOWGRIDS: + if (!value) { // don't show grids if not specified, for backwards compatibility + nv->grids_visible = false; + } else { + nv->grids_visible = sp_str_to_bool(value); } - sp_namedview_setup_grid(nv); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); - break; - case SP_ATTR_GRIDOPACITY: - nv->gridcolor = (nv->gridcolor & 0xffffff00) | (DEFAULTGRIDCOLOR & 0xff); - sp_nv_read_opacity(value, &nv->gridcolor); - sp_namedview_setup_grid(nv); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_GRIDEMPOPACITY: - nv->gridempcolor = (nv->gridempcolor & 0xffffff00) | (DEFAULTGRIDEMPCOLOR & 0xff); - sp_nv_read_opacity(value, &nv->gridempcolor); - sp_namedview_setup_grid(nv); + case SP_ATTR_GRIDTOLERANCE: + nv->snap_manager.snapprefs.setGridTolerance(value ? g_ascii_strtod(value, NULL) : 10000); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_GUIDETOLERANCE: + nv->snap_manager.snapprefs.setGuideTolerance(value ? g_ascii_strtod(value, NULL) : 20); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_GRIDEMPSPACING: - nv->gridempspacing = DEFAULTGRIDEMPSPACING; - if (value != NULL) - nv->gridempspacing = atoi(value); - sp_namedview_setup_grid(nv); + case SP_ATTR_OBJECTTOLERANCE: + nv->snap_manager.snapprefs.setObjectTolerance(value ? g_ascii_strtod(value, NULL) : 20); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_GUIDECOLOR: + case SP_ATTR_GUIDECOLOR: nv->guidecolor = (nv->guidecolor & 0xff) | (DEFAULTGUIDECOLOR & 0xffffff00); if (value) { nv->guidecolor = (nv->guidecolor & 0xff) | sp_svg_read_color(value, nv->guidecolor); @@ -357,7 +350,7 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va } object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_GUIDEOPACITY: + case SP_ATTR_GUIDEOPACITY: nv->guidecolor = (nv->guidecolor & 0xffffff00) | (DEFAULTGUIDECOLOR & 0xff); sp_nv_read_opacity(value, &nv->guidecolor); for (GSList *l = nv->guides; l != NULL; l = l->next) { @@ -365,7 +358,7 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va } object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_GUIDEHICOLOR: + case SP_ATTR_GUIDEHICOLOR: nv->guidehicolor = (nv->guidehicolor & 0xff) | (DEFAULTGUIDEHICOLOR & 0xffffff00); if (value) { nv->guidehicolor = (nv->guidehicolor & 0xff) | sp_svg_read_color(value, nv->guidehicolor); @@ -375,7 +368,7 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va } object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_GUIDEHIOPACITY: + case SP_ATTR_GUIDEHIOPACITY: nv->guidehicolor = (nv->guidehicolor & 0xffffff00) | (DEFAULTGUIDEHICOLOR & 0xff); sp_nv_read_opacity(value, &nv->guidehicolor); for (GSList *l = nv->guides; l != NULL; l = l->next) { @@ -383,125 +376,161 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va } object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_SHOWBORDER: + case SP_ATTR_SHOWBORDER: nv->showborder = (value) ? sp_str_to_bool (value) : TRUE; object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_BORDERLAYER: + case SP_ATTR_BORDERLAYER: nv->borderlayer = SP_BORDER_LAYER_BOTTOM; if (value && !strcasecmp(value, "true")) nv->borderlayer = SP_BORDER_LAYER_TOP; object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_BORDERCOLOR: + case SP_ATTR_BORDERCOLOR: nv->bordercolor = (nv->bordercolor & 0xff) | (DEFAULTBORDERCOLOR & 0xffffff00); if (value) { nv->bordercolor = (nv->bordercolor & 0xff) | sp_svg_read_color (value, nv->bordercolor); } object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_BORDEROPACITY: + case SP_ATTR_BORDEROPACITY: nv->bordercolor = (nv->bordercolor & 0xffffff00) | (DEFAULTBORDERCOLOR & 0xff); sp_nv_read_opacity(value, &nv->bordercolor); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_PAGECOLOR: + case SP_ATTR_PAGECOLOR: nv->pagecolor = (nv->pagecolor & 0xff) | (DEFAULTPAGECOLOR & 0xffffff00); if (value) { nv->pagecolor = (nv->pagecolor & 0xff) | sp_svg_read_color(value, nv->pagecolor); } object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_PAGEOPACITY: + case SP_ATTR_INKSCAPE_PAGEOPACITY: nv->pagecolor = (nv->pagecolor & 0xffffff00) | (DEFAULTPAGECOLOR & 0xff); sp_nv_read_opacity(value, &nv->pagecolor); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_PAGESHADOW: + case SP_ATTR_INKSCAPE_PAGESHADOW: nv->pageshadow = value? atoi(value) : 2; // 2 is the default object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_SHOWPAGESHADOW: + case SP_ATTR_SHOWPAGESHADOW: nv->showpageshadow = (value) ? sp_str_to_bool(value) : TRUE; object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_ZOOM: + case SP_ATTR_INKSCAPE_ZOOM: nv->zoom = value ? g_ascii_strtod(value, NULL) : 0; // zero means not set object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_CX: + case SP_ATTR_INKSCAPE_CX: nv->cx = value ? g_ascii_strtod(value, NULL) : HUGE_VAL; // HUGE_VAL means not set object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_CY: + case SP_ATTR_INKSCAPE_CY: nv->cy = value ? g_ascii_strtod(value, NULL) : HUGE_VAL; // HUGE_VAL means not set object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_WINDOW_WIDTH: + case SP_ATTR_INKSCAPE_WINDOW_WIDTH: nv->window_width = value? atoi(value) : -1; // -1 means not set object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_WINDOW_HEIGHT: + case SP_ATTR_INKSCAPE_WINDOW_HEIGHT: nv->window_height = value ? atoi(value) : -1; // -1 means not set object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_WINDOW_X: - nv->window_x = value ? atoi(value) : -1; // -1 means not set + case SP_ATTR_INKSCAPE_WINDOW_X: + nv->window_x = value ? atoi(value) : 0; + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_WINDOW_Y: + nv->window_y = value ? atoi(value) : 0; + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_WINDOW_MAXIMIZED: + nv->window_maximized = value ? atoi(value) : 0; + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_SNAP_GLOBAL: + nv->snap_manager.snapprefs.setSnapEnabledGlobally(value ? sp_str_to_bool(value) : TRUE); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_SNAP_BBOX: + nv->snap_manager.snapprefs.setSnapModeBBox(value ? sp_str_to_bool(value) : FALSE); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_SNAP_NODES: + nv->snap_manager.snapprefs.setSnapModeNode(value ? sp_str_to_bool(value) : TRUE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_WINDOW_Y: - nv->window_y = value ? atoi(value) : -1; // -1 means not set + case SP_ATTR_INKSCAPE_SNAP_CENTER: + nv->snap_manager.snapprefs.setIncludeItemCenter(value ? sp_str_to_bool(value) : FALSE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_GRID_BBOX: - nv->snap_grid_bbox = (value) ? sp_str_to_bool(value) : TRUE; - nv->grid_snapper.setSnapTo(Inkscape::Snapper::BBOX_POINT, nv->showgrid && nv->snap_grid_bbox); + case SP_ATTR_INKSCAPE_SNAP_GRIDS: + nv->snap_manager.snapprefs.setSnapToGrids(value ? sp_str_to_bool(value) : TRUE); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_SNAP_TO_GUIDES: + nv->snap_manager.snapprefs.setSnapToGuides(value ? sp_str_to_bool(value) : TRUE); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES: + nv->snap_manager.snapprefs.setSnapSmoothNodes(value ? sp_str_to_bool(value) : FALSE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_GRID_POINTS: - nv->snap_grid_point = (value) ? sp_str_to_bool(value) : FALSE; - nv->grid_snapper.setSnapTo(Inkscape::Snapper::SNAP_POINT, nv->showgrid && nv->snap_grid_point); + case SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS: + nv->snap_manager.snapprefs.setSnapLineMidpoints(value ? sp_str_to_bool(value) : FALSE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_GUIDE_BBOX: - nv->snap_guide_bbox = (value) ? sp_str_to_bool(value) : TRUE; - nv->guide_snapper.setSnapTo(Inkscape::Snapper::BBOX_POINT, nv->showguides && nv->snap_guide_bbox); + case SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS: + nv->snap_manager.snapprefs.setSnapObjectMidpoints(value ? sp_str_to_bool(value) : FALSE); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS: + nv->snap_manager.snapprefs.setSnapBBoxEdgeMidpoints(value ? sp_str_to_bool(value) : FALSE); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS: + nv->snap_manager.snapprefs.setSnapBBoxMidpoints(value ? sp_str_to_bool(value) : FALSE); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_SNAP_FROM_GUIDE: + nv->snap_manager.snapprefs.setSnapModeGuide(value ? sp_str_to_bool(value) : TRUE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_GUIDE_POINTS: - nv->snap_guide_point = (value) ? sp_str_to_bool(value) : FALSE; - nv->guide_snapper.setSnapTo(Inkscape::Snapper::SNAP_POINT, nv->showguides && nv->snap_guide_point); + case SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS: + nv->snap_manager.snapprefs.setSnapIntersectionCS(value ? sp_str_to_bool(value) : FALSE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_OBJECT_BBOX: - nv->snap_object_bbox = (value) ? sp_str_to_bool(value) : FALSE; - nv->object_snapper.setSnapTo(Inkscape::Snapper::BBOX_POINT, nv->snap_object_bbox); + case SP_ATTR_INKSCAPE_OBJECT_PATHS: + nv->snap_manager.snapprefs.setSnapToItemPath(value ? sp_str_to_bool(value) : FALSE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_OBJECT_POINTS: - nv->snap_object_point = (value) ? sp_str_to_bool(value) : FALSE; - nv->object_snapper.setSnapTo(Inkscape::Snapper::SNAP_POINT, nv->snap_object_point); + case SP_ATTR_INKSCAPE_OBJECT_NODES: + nv->snap_manager.snapprefs.setSnapToItemNode(value ? sp_str_to_bool(value) : FALSE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_OBJECT_PATHS: - nv->snap_object_paths = (value) ? sp_str_to_bool(value) : TRUE; - nv->object_snapper.setSnapToPaths(nv->snap_object_paths); + case SP_ATTR_INKSCAPE_BBOX_PATHS: + nv->snap_manager.snapprefs.setSnapToBBoxPath(value ? sp_str_to_bool(value) : FALSE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_OBJECT_NODES: - nv->snap_object_nodes = (value) ? sp_str_to_bool(value) : TRUE; - nv->object_snapper.setSnapToNodes(nv->snap_object_nodes); + case SP_ATTR_INKSCAPE_BBOX_NODES: + nv->snap_manager.snapprefs.setSnapToBBoxNode(value ? sp_str_to_bool(value) : FALSE); object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_CURRENT_LAYER: + case SP_ATTR_INKSCAPE_SNAP_PAGE: + nv->snap_manager.snapprefs.setSnapToPageBorder(value ? sp_str_to_bool(value) : FALSE); + object->requestModified(SP_OBJECT_MODIFIED_FLAG); + break; + case SP_ATTR_INKSCAPE_CURRENT_LAYER: nv->default_layer_id = value ? g_quark_from_string(value) : 0; object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_CONNECTOR_SPACING: + case SP_ATTR_INKSCAPE_CONNECTOR_SPACING: nv->connector_spacing = value ? g_ascii_strtod(value, NULL) : defaultConnSpacing; object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - case SP_ATTR_INKSCAPE_DOCUMENT_UNITS: { + case SP_ATTR_INKSCAPE_DOCUMENT_UNITS: { /* The default unit if the document doesn't override this: e.g. for files saved as * `plain SVG', or non-inkscape files, or files created by an inkscape 0.40 & * earlier. @@ -541,8 +570,8 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va nv->doc_units = new_unit; object->requestModified(SP_OBJECT_MODIFIED_FLAG); break; - } - default: + } + default: if (((SPObjectClass *) (parent_class))->set) { ((SPObjectClass *) (parent_class))->set(object, key, value); } @@ -550,6 +579,47 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va } } +/** +* add a grid item from SVG-repr. Check if this namedview already has a gridobject for this one! If desktop=null, add grid-canvasitem to all desktops of this namedview, +* otherwise only add it to the specified desktop. +*/ +static Inkscape::CanvasGrid* +sp_namedview_add_grid(SPNamedView *nv, Inkscape::XML::Node *repr, SPDesktop *desktop) { + Inkscape::CanvasGrid* grid = NULL; + //check if namedview already has an object for this grid + for (GSList *l = nv->grids; l != NULL; l = l->next) { + Inkscape::CanvasGrid* g = (Inkscape::CanvasGrid*) l->data; + if (repr == g->repr) { + grid = g; + break; + } + } + + if (!grid) { + //create grid object + Inkscape::GridType gridtype = Inkscape::CanvasGrid::getGridTypeFromSVGName(repr->attribute("type")); + if (!nv->document) { + g_warning("sp_namedview_add_grid - how come doc is null here?!"); + return NULL; + } + grid = Inkscape::CanvasGrid::NewGrid(nv, repr, nv->document, gridtype); + nv->grids = g_slist_append(nv->grids, grid); + } + + if (!desktop) { + //add canvasitem to all desktops + for (GSList *l = nv->views; l != NULL; l = l->next) { + SPDesktop *dt = static_cast(l->data); + grid->createCanvasItem(dt); + } + } else { + //add canvasitem only for specified desktop + grid->createCanvasItem(desktop); + } + + return grid; +} + static void sp_namedview_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref) { SPNamedView *nv = (SPNamedView *) object; @@ -558,29 +628,25 @@ static void sp_namedview_child_added(SPObject *object, Inkscape::XML::Node *chil (* ((SPObjectClass *) (parent_class))->child_added)(object, child, ref); } - const gchar *id = child->attribute("id"); - SPObject *no = object->document->getObjectById(id); - g_assert(SP_IS_OBJECT(no)); - - if (SP_IS_GUIDE(no)) { - SPGuide *g = (SPGuide *) no; - nv->guides = g_slist_prepend(nv->guides, g); - g_object_set(G_OBJECT(g), "color", nv->guidecolor, "hicolor", nv->guidehicolor, NULL); - if (nv->editable) { - for (GSList *l = nv->views; l != NULL; l = l->next) { - sp_guide_show(g, static_cast(l->data)->guides, (GCallback) sp_dt_guide_event); - if (static_cast(l->data)->guides_active) - sp_guide_sensitize(g, - SP_DT_CANVAS(static_cast (l->data)), - TRUE); - if (nv->showguides) { - for (GSList *v = SP_GUIDE(g)->views; v != NULL; v = v->next) { - sp_canvas_item_show(SP_CANVAS_ITEM(v->data)); - } - } else { - for (GSList *v = SP_GUIDE(g)->views; v != NULL; v = v->next) { - sp_canvas_item_hide(SP_CANVAS_ITEM(v->data)); - } + if (!strcmp(child->name(), "inkscape:grid")) { + sp_namedview_add_grid(nv, child, NULL); + } else { + SPObject *no = object->document->getObjectByRepr(child); + if ( !SP_IS_OBJECT(no) ) + return; + + if (SP_IS_GUIDE(no)) { + SPGuide *g = (SPGuide *) no; + nv->guides = g_slist_prepend(nv->guides, g); + g_object_set(G_OBJECT(g), "color", nv->guidecolor, "hicolor", nv->guidehicolor, NULL); + if (nv->editable) { + for (GSList *l = nv->views; l != NULL; l = l->next) { + sp_guide_show(g, static_cast(l->data)->guides, (GCallback) sp_dt_guide_event); + if (static_cast(l->data)->guides_active) + sp_guide_sensitize(g, + sp_desktop_canvas(static_cast (l->data)), + TRUE); + sp_namedview_show_single_guide(SP_GUIDE(g), nv->showguides); } } } @@ -591,15 +657,26 @@ static void sp_namedview_remove_child(SPObject *object, Inkscape::XML::Node *chi { SPNamedView *nv = (SPNamedView *) object; - GSList **ref = &nv->guides; - for ( GSList *iter = nv->guides ; iter ; iter = iter->next ) { - if ( SP_OBJECT_REPR((SPObject *)iter->data) == child ) { - *ref = iter->next; - iter->next = NULL; - g_slist_free_1(iter); - break; + if (!strcmp(child->name(), "inkscape:grid")) { + for ( GSList *iter = nv->grids ; iter ; iter = iter->next ) { + Inkscape::CanvasGrid *gr = (Inkscape::CanvasGrid *)iter->data; + if ( gr->repr == child ) { + delete gr; + nv->grids = g_slist_remove_link(nv->grids, iter); + break; + } + } + } else { + GSList **ref = &nv->guides; + for ( GSList *iter = nv->guides ; iter ; iter = iter->next ) { + if ( SP_OBJECT_REPR((SPObject *)iter->data) == child ) { + *ref = iter->next; + iter->next = NULL; + g_slist_free_1(iter); + break; + } + ref = &iter->next; } - ref = &iter->next; } if (((SPObjectClass *) (parent_class))->remove_child) { @@ -607,7 +684,7 @@ static void sp_namedview_remove_child(SPObject *object, Inkscape::XML::Node *chi } } -static Inkscape::XML::Node *sp_namedview_write(SPObject *object, Inkscape::XML::Node *repr, guint flags) +static Inkscape::XML::Node *sp_namedview_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) { if ( ( flags & SP_OBJECT_WRITE_EXT ) && repr != SP_OBJECT_REPR(object) ) @@ -615,7 +692,7 @@ static Inkscape::XML::Node *sp_namedview_write(SPObject *object, Inkscape::XML:: if (repr) { repr->mergeFrom(SP_OBJECT_REPR(object), "id"); } else { - repr = SP_OBJECT_REPR(object)->duplicate(); + repr = SP_OBJECT_REPR(object)->duplicate(doc); } } @@ -627,50 +704,66 @@ void SPNamedView::show(SPDesktop *desktop) for (GSList *l = guides; l != NULL; l = l->next) { sp_guide_show(SP_GUIDE(l->data), desktop->guides, (GCallback) sp_dt_guide_event); if (desktop->guides_active) { - sp_guide_sensitize(SP_GUIDE(l->data), SP_DT_CANVAS(desktop), TRUE); - } - if (showguides) { - for (GSList *v = SP_GUIDE(l->data)->views; v != NULL; v = v->next) { - sp_canvas_item_show(SP_CANVAS_ITEM(v->data)); - } - } else { - for (GSList *v = SP_GUIDE(l->data)->views; v != NULL; v = v->next) { - sp_canvas_item_hide(SP_CANVAS_ITEM(v->data)); - } + sp_guide_sensitize(SP_GUIDE(l->data), sp_desktop_canvas(desktop), TRUE); } + sp_namedview_show_single_guide(SP_GUIDE(l->data), showguides); } views = g_slist_prepend(views, desktop); - SPCanvasItem *item = sp_canvas_item_new(SP_DT_GRID(desktop), SP_TYPE_CGRID, NULL); - // since we're keeping a copy, we need to bump up the ref count - gtk_object_ref(GTK_OBJECT(item)); - gridviews = g_slist_prepend(gridviews, item); - sp_namedview_setup_grid_item(this, item); + // generate grids specified in SVG: + Inkscape::XML::Node *repr = SP_OBJECT_REPR(this); + if (repr) { + for (Inkscape::XML::Node * child = repr->firstChild() ; child != NULL; child = child->next() ) { + if (!strcmp(child->name(), "inkscape:grid")) { + sp_namedview_add_grid(this, child, desktop); + } + } + } + + desktop->showGrids(grids_visible, false); } +#define MIN_ONSCREEN_DISTANCE 50 + /* - * Restores window geometry from the document settings + * Restores window geometry from the document settings or defaults in prefs */ void sp_namedview_window_from_document(SPDesktop *desktop) { SPNamedView *nv = desktop->namedview; - gint save_geometry = prefs_get_int_attribute("options.savewindowgeometry", "value", 0); - - // restore window size and position - if (save_geometry) { - if (nv->window_width != -1 && nv->window_height != -1) - desktop->setWindowSize(nv->window_width, nv->window_height); - if (nv->window_x != -1 && nv->window_y != -1) - desktop->setWindowPosition(NR::Point(nv->window_x, nv->window_y)); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + bool geometry_from_file = prefs->getBool("/options/savewindowgeometry/value"); + + // restore window size and position stored with the document + if (geometry_from_file) { + if (nv->window_maximized) { + Gtk::Window *win = desktop->getToplevel(); + if (win){ + win->maximize(); + } + } else { + gint w = MIN(gdk_screen_width(), nv->window_width); + gint h = MIN(gdk_screen_height(), nv->window_height); + // prevent the window from moving off the screen to the right or to the bottom + gint x = MIN(gdk_screen_width() - MIN_ONSCREEN_DISTANCE, nv->window_x); + gint y = MIN(gdk_screen_height() - MIN_ONSCREEN_DISTANCE, nv->window_y); + // prevent the window from moving off the screen to the left or to the top + x = MAX(MIN_ONSCREEN_DISTANCE - nv->window_width, x); + y = MAX(MIN_ONSCREEN_DISTANCE - nv->window_height, y); + if (w>0 && h>0) { + desktop->setWindowSize(w, h); + desktop->setWindowPosition(Geom::Point(x, y)); + } + } } // restore zoom and view - if (nv->zoom != 0 && nv->zoom != HUGE_VAL && !isNaN(nv->zoom) - && nv->cx != HUGE_VAL && !isNaN(nv->cx) - && nv->cy != HUGE_VAL && !isNaN(nv->cy)) { + if (nv->zoom != 0 && nv->zoom != HUGE_VAL && !IS_NAN(nv->zoom) + && nv->cx != HUGE_VAL && !IS_NAN(nv->cx) + && nv->cy != HUGE_VAL && !IS_NAN(nv->cy)) { desktop->zoom_absolute(nv->cx, nv->cy, nv->zoom); - } else if (SP_DT_DOCUMENT(desktop)) { // document without saved zoom, zoom to its page + } else if (sp_desktop_document(desktop)) { // document without saved zoom, zoom to its page desktop->zoom_page(); } @@ -679,9 +772,13 @@ void sp_namedview_window_from_document(SPDesktop *desktop) g_list_free(desktop->zooms_past); desktop->zooms_past = NULL; } +} +void sp_namedview_update_layers_from_document (SPDesktop *desktop) +{ SPObject *layer = NULL; SPDocument *document = desktop->doc(); + SPNamedView *nv = desktop->namedview; if ( nv->default_layer_id != 0 ) { layer = document->getObjectById(g_quark_to_string(nv->default_layer_id)); } @@ -701,35 +798,40 @@ void sp_namedview_window_from_document(SPDesktop *desktop) if (layer) { desktop->setCurrentLayer(layer); } + + // FIXME: find a better place to do this + desktop->event_log->updateUndoVerbs(); } void sp_namedview_document_from_window(SPDesktop *desktop) { - gint save_geometry = prefs_get_int_attribute("options.savewindowgeometry", "value", 0); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + bool save_geometry_in_file = prefs->getBool("/options/savewindowgeometry/value", 0); Inkscape::XML::Node *view = SP_OBJECT_REPR(desktop->namedview); - NR::Rect const r = desktop->get_display_area(); + Geom::Rect const r = desktop->get_display_area(); // saving window geometry is not undoable - gboolean saved = sp_document_get_undo_sensitive(SP_DT_DOCUMENT(desktop)); - sp_document_set_undo_sensitive(SP_DT_DOCUMENT(desktop), FALSE); + bool saved = sp_document_get_undo_sensitive(sp_desktop_document(desktop)); + sp_document_set_undo_sensitive(sp_desktop_document(desktop), false); sp_repr_set_svg_double(view, "inkscape:zoom", desktop->current_zoom()); - sp_repr_set_svg_double(view, "inkscape:cx", r.midpoint()[NR::X]); - sp_repr_set_svg_double(view, "inkscape:cy", r.midpoint()[NR::Y]); + sp_repr_set_svg_double(view, "inkscape:cx", r.midpoint()[Geom::X]); + sp_repr_set_svg_double(view, "inkscape:cy", r.midpoint()[Geom::Y]); - if (save_geometry) { - gint w, h, x, y; + if (save_geometry_in_file) { + gint w, h, x, y; desktop->getWindowGeometry(x, y, w, h); sp_repr_set_int(view, "inkscape:window-width", w); sp_repr_set_int(view, "inkscape:window-height", h); sp_repr_set_int(view, "inkscape:window-x", x); sp_repr_set_int(view, "inkscape:window-y", y); + sp_repr_set_int(view, "inkscape:window-maximized", desktop->is_maximized()); } view->setAttribute("inkscape:current-layer", SP_OBJECT_ID(desktop->currentLayer())); // restore undoability - sp_document_set_undo_sensitive(SP_DT_DOCUMENT(desktop), saved); + sp_document_set_undo_sensitive(sp_desktop_document(desktop), saved); } void SPNamedView::hide(SPDesktop const *desktop) @@ -738,23 +840,10 @@ void SPNamedView::hide(SPDesktop const *desktop) g_assert(g_slist_find(views, desktop)); for (GSList *l = guides; l != NULL; l = l->next) { - sp_guide_hide(SP_GUIDE(l->data), SP_DT_CANVAS(desktop)); + sp_guide_hide(SP_GUIDE(l->data), sp_desktop_canvas(desktop)); } views = g_slist_remove(views, desktop); - - GSList *l; - for (l = gridviews; l != NULL; l = l->next) { - if (SP_CANVAS_ITEM(l->data)->canvas == SP_DT_CANVAS(desktop)) { - break; - } - } - - g_assert(l); - - sp_canvas_item_hide(SP_CANVAS_ITEM(l->data)); - gtk_object_unref(GTK_OBJECT(l->data)); - gridviews = g_slist_remove(gridviews, l->data); } void SPNamedView::activateGuides(gpointer desktop, gboolean active) @@ -765,25 +854,30 @@ void SPNamedView::activateGuides(gpointer desktop, gboolean active) SPDesktop *dt = static_cast(desktop); for (GSList *l = guides; l != NULL; l = l->next) { - sp_guide_sensitize(SP_GUIDE(l->data), SP_DT_CANVAS(dt), active); + sp_guide_sensitize(SP_GUIDE(l->data), sp_desktop_canvas(dt), active); } } static void sp_namedview_setup_guides(SPNamedView *nv) { for (GSList *l = nv->guides; l != NULL; l = l->next) { - if (nv->showguides) { - for (GSList *v = SP_GUIDE(l->data)->views; v != NULL; v = v->next) { - sp_canvas_item_show(SP_CANVAS_ITEM(v->data)); - } - } else { - for (GSList *v = SP_GUIDE(l->data)->views; v != NULL; v = v->next) { - sp_canvas_item_hide(SP_CANVAS_ITEM(v->data)); - } - } + sp_namedview_show_single_guide(SP_GUIDE(l->data), nv->showguides); } } +static void sp_namedview_show_single_guide(SPGuide* guide, bool show) +{ + for (GSList *v = guide->views; v != NULL; v = v->next) { + if (show) { + sp_canvas_item_show(SP_CANVAS_ITEM(v->data)); + sp_canvas_item_show(SP_CANVAS_ITEM(SP_GUIDELINE(v->data)->origin)); + } else { + sp_canvas_item_hide(SP_CANVAS_ITEM(v->data)); + sp_canvas_item_hide(SP_CANVAS_ITEM(SP_GUIDELINE(v->data)->origin)); + } + } +} + void sp_namedview_toggle_guides(SPDocument *doc, Inkscape::XML::Node *repr) { unsigned int v; @@ -794,56 +888,33 @@ void sp_namedview_toggle_guides(SPDocument *doc, Inkscape::XML::Node *repr) v = !v; } - gboolean saved = sp_document_get_undo_sensitive(doc); - sp_document_set_undo_sensitive(doc, FALSE); - + bool saved = sp_document_get_undo_sensitive(doc); + sp_document_set_undo_sensitive(doc, false); sp_repr_set_boolean(repr, "showguides", v); - - doc->rroot->setAttribute("sodipodi:modified", "true"); sp_document_set_undo_sensitive(doc, saved); + + doc->setModifiedSinceSave(); } -void sp_namedview_toggle_grid(SPDocument *doc, Inkscape::XML::Node *repr) +void sp_namedview_show_grids(SPNamedView * namedview, bool show, bool dirty_document) { - unsigned int v; - sp_repr_get_boolean(repr, "showgrid", &v); - v = !v; - - gboolean saved = sp_document_get_undo_sensitive(doc); - sp_document_set_undo_sensitive(doc, FALSE); + namedview->grids_visible = show; - sp_repr_set_boolean(repr, "showgrid", v); + SPDocument *doc = SP_OBJECT_DOCUMENT (namedview); + Inkscape::XML::Node *repr = SP_OBJECT_REPR(namedview); - doc->rroot->setAttribute("sodipodi:modified", "true"); + bool saved = sp_document_get_undo_sensitive(doc); + sp_document_set_undo_sensitive(doc, false); + sp_repr_set_boolean(repr, "showgrid", namedview->grids_visible); sp_document_set_undo_sensitive(doc, saved); -} -static void sp_namedview_setup_grid(SPNamedView *nv) -{ - for (GSList *l = nv->gridviews; l != NULL; l = l->next) { - sp_namedview_setup_grid_item(nv, SP_CANVAS_ITEM(l->data)); + /* we don't want the document to get dirty on startup; that's when + we call this function with dirty_document = false */ + if (dirty_document) { + doc->setModifiedSinceSave(); } } -static void sp_namedview_setup_grid_item(SPNamedView *nv, SPCanvasItem *item) -{ - if (nv->showgrid) { - sp_canvas_item_show(item); - } else { - sp_canvas_item_hide(item); - } - - sp_canvas_item_set((GtkObject *) item, - "color", nv->gridcolor, - "originx", nv->gridorigin[NR::X], - "originy", nv->gridorigin[NR::Y], - "spacingx", nv->gridspacing[NR::X], - "spacingy", nv->gridspacing[NR::Y], - "empcolor", nv->gridempcolor, - "empspacing", nv->gridempspacing, - NULL); -} - gchar const *SPNamedView::getName() const { SPException ex; @@ -877,58 +948,6 @@ static gboolean sp_str_to_bool(const gchar *str) return FALSE; } -/* fixme: Collect all these length parsing methods and think common sane API */ - -static gboolean sp_nv_read_length(const gchar *str, guint base, gdouble *val, const SPUnit **unit) -{ - if (!str) { - return FALSE; - } - - gchar *u; - gdouble v = g_ascii_strtod(str, &u); - if (!u) { - return FALSE; - } - while (isspace(*u)) { - u += 1; - } - - if (!*u) { - /* No unit specified - keep default */ - *val = v; - return TRUE; - } - - if (base & SP_UNIT_DEVICE) { - if (u[0] && u[1] && !isalnum(u[2]) && !strncmp(u, "px", 2)) { - *unit = &sp_unit_get_by_id(SP_UNIT_PX); - *val = v; - return TRUE; - } - } - - if (base & SP_UNIT_ABSOLUTE) { - if (!strncmp(u, "pt", 2)) { - *unit = &sp_unit_get_by_id(SP_UNIT_PT); - } else if (!strncmp(u, "mm", 2)) { - *unit = &sp_unit_get_by_id(SP_UNIT_MM); - } else if (!strncmp(u, "cm", 2)) { - *unit = &sp_unit_get_by_id(SP_UNIT_CM); - } else if (!strncmp(u, "m", 1)) { - *unit = &sp_unit_get_by_id(SP_UNIT_M); - } else if (!strncmp(u, "in", 2)) { - *unit = &sp_unit_get_by_id(SP_UNIT_IN); - } else { - return FALSE; - } - *val = v; - return TRUE; - } - - return FALSE; -} - static gboolean sp_nv_read_opacity(const gchar *str, guint32 *color) { if (!str) { @@ -936,7 +955,7 @@ static gboolean sp_nv_read_opacity(const gchar *str, guint32 *color) } gchar *u; - gdouble v = strtod(str, &u); + gdouble v = g_ascii_strtod(str, &u); if (!u) { return FALSE; } @@ -977,15 +996,38 @@ SPMetric SPNamedView::getDefaultMetric() const } } -SPNamedView::SnapperList SPNamedView::getSnappers() const +/** + * Returns the first grid it could find that isEnabled(). Returns NULL, if none is enabled + */ +Inkscape::CanvasGrid * sp_namedview_get_first_enabled_grid(SPNamedView *namedview) { - SnapperList s; - s.push_back(&grid_snapper); - s.push_back(&guide_snapper); - s.push_back(&object_snapper); - return s; + for (GSList const * l = namedview->grids; l != NULL; l = l->next) { + Inkscape::CanvasGrid * grid = (Inkscape::CanvasGrid*) l->data; + if (grid->isEnabled()) + return grid; + } + + return NULL; +} + +void SPNamedView::translateGuides(Geom::Translate const &tr) { + for (GSList *l = guides; l != NULL; l = l->next) { + SPGuide &guide = *SP_GUIDE(l->data); + Geom::Point point_on_line = guide.point_on_line; + point_on_line[0] += tr[0]; + point_on_line[1] += tr[1]; + sp_guide_moveto(guide, point_on_line, true); + } } +void SPNamedView::scrollAllDesktops(double dx, double dy, bool is_scrolling) { + for(GSList *l = views; l; l = l->next) { + SPDesktop *desktop = static_cast(l->data); + desktop->scroll_world_in_svg_coords(dx, dy, is_scrolling); + } +} + + /* Local Variables: mode:c++ @@ -995,4 +1037,4 @@ SPNamedView::SnapperList SPNamedView::getSnappers() const fill-column:99 End: */ -// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :