#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <gtk/gtkwindow.h>

#include <gtk/gtkversion.h>

#include <gtk/gtklabel.h>

#include <gtkmm/radioaction.h>

#include <gtkmm/menubar.h>

#include <gtkmm/messagedialog.h>

#include <gtkmm/stock.h>

#include <gtkmm/accelmap.h>

#include <gtkmm/separator.h>

#include <gtkmm/base.h>

#include <sigc++/functors/mem_fun.h>

#include "macros.h"

#include "path-prefix.h"

#include "preferences.h"

#include "file.h"

#include "application/editor.h"

#include "edit-widget.h"

#include "display/sodipodi-ctrlrect.h"

#include "helper/units.h"

#include "shortcuts.h"

#include "widgets/spw-utilities.h"

#include "event-context.h"

#include "document.h"

#include "sp-namedview.h"

#include "sp-item.h"

#include "interface.h"

#include "extension/db.h"

#include "ui/dialog/dialog-manager.h"

using namespace Inkscape::UI;

using namespace Inkscape::UI::Widget;

namespace Inkscape {

namespace UI {

namespace View {

EditWidget::EditWidget (SPDocument *doc)

: _main_window_table(4),

_viewport_table(3,3),

_act_grp(Gtk::ActionGroup::create()),

_ui_mgr(Gtk::UIManager::create()),

_update_s_f(false),

_update_a_f(false),

_interaction_disabled_counter(0)

{

g_warning("Creating new EditWidget");

_desktop = 0;

initActions();

initAccelMap();

initUIManager();

initLayout();

initEdit (doc);

g_warning("Done creating new EditWidget");

}

EditWidget::~EditWidget()

{

destroyEdit();

}

EditWidget::initActions()

{

initMenuActions();

initToolbarActions();

}

EditWidget::initUIManager()

{

_ui_mgr->insert_action_group(_act_grp);

add_accel_group(_ui_mgr->get_accel_group());

gchar *filename_utf8 = g_build_filename(INKSCAPE_UIDIR, "menus-bars.xml", NULL);

if (_ui_mgr->add_ui_from_file(filename_utf8) == 0) {

g_warning("Error merging ui from file '%s'", filename_utf8);

// fixme-charset: What charset should we pass to g_warning?

}

g_free(filename_utf8);

}

EditWidget::initLayout()

{

set_title("New document 1 - Inkscape");

set_resizable();

set_default_size(640, 480);

// top level window into which all other portions of the UI get inserted

add(_main_window_table);

// attach box for horizontal toolbars

_main_window_table.attach(_toolbars_vbox, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::SHRINK);

// attach sub-window for viewport and vertical toolbars

_main_window_table.attach(_sub_window_hbox, 0, 1, 2, 3);

// viewport table with 3 rows by 3 columns

_sub_window_hbox.pack_end(_viewport_table);

// Menus and Bars

initMenuBar();

initCommandsBar();

initToolControlsBar();

initUriBar();

initToolsBar();

// Canvas Viewport

initLeftRuler();

initTopRuler();

initStickyZoom();

initBottomScrollbar();

initRightScrollbar();

_viewport_table.attach(_svg_canvas.widget(), 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);

_svg_canvas.widget().show_all();

// The statusbar comes last and appears at the bottom of _main_window_table

initStatusbar();

signal_size_allocate().connect (sigc::mem_fun (*this, &EditWidget::onWindowSizeAllocate), false);

signal_realize().connect (sigc::mem_fun (*this, &EditWidget::onWindowRealize));

show_all_children();

}

EditWidget::onMenuItem()

{

g_warning("onMenuItem called");

}

EditWidget::onActionFileNew()

{

sp_file_new_default();

}

EditWidget::onActionFileOpen()

{

sp_file_open_dialog (*this, NULL, NULL);

}

EditWidget::onActionFileQuit()

{

g_warning("onActionFileQuit");

sp_ui_close_all();

}

EditWidget::onActionFilePrint()

{

g_warning("onActionFilePrint");

}

EditWidget::onToolbarItem()

{

g_warning("onToolbarItem called");

}

EditWidget::onSelectTool()

{

_tool_ctrl->remove();

_tool_ctrl->add(*_select_ctrl);

}

EditWidget::onNodeTool()

{

_tool_ctrl->remove();

_tool_ctrl->add(*_node_ctrl);

}

EditWidget::onDialogInkscapePreferences()

{

_dlg_mgr.showDialog("InkscapePreferences");

}

EditWidget::onDialogAbout()

{

}

EditWidget::onDialogAlignAndDistribute()

{

_dlg_mgr.showDialog("AlignAndDistribute");

}

EditWidget::onDialogDocumentProperties()

{

_dlg_mgr.showDialog("DocumentPreferences");

}

EditWidget::onDialogExport()

{

_dlg_mgr.showDialog("Export");

}

EditWidget::onDialogExtensionEditor()

{

_dlg_mgr.showDialog("ExtensionEditor");

}

EditWidget::onDialogFillAndStroke()

{

_dlg_mgr.showDialog("FillAndStroke");

}

EditWidget::onDialogFind()

{

_dlg_mgr.showDialog("Find");

}

EditWidget::onDialogLayerEditor()

{

_dlg_mgr.showDialog("LayerEditor");

}

EditWidget::onDialogMessages()

{

_dlg_mgr.showDialog("Messages");

}

EditWidget::onDialogObjectProperties()

{

_dlg_mgr.showDialog("ObjectProperties");

}

EditWidget::onDialogTextProperties()

{

_dlg_mgr.showDialog("TextProperties");

}

EditWidget::onDialogTrace()

{

}

EditWidget::onDialogTransformation()

{

_dlg_mgr.showDialog("Transformation");

}

EditWidget::onDialogXmlEditor()

{

_dlg_mgr.showDialog("XmlEditor");

}

EditWidget::onUriChanged()

{

g_message("onUriChanged called");

}

EditWidget::initMenuActions()

{

_act_grp->add(Gtk::Action::create("MenuFile", "File"));

_act_grp->add(Gtk::Action::create("MenuEdit", "Edit"));

_act_grp->add(Gtk::Action::create("MenuView", "View"));

_act_grp->add(Gtk::Action::create("MenuLayer", "Layer"));

_act_grp->add(Gtk::Action::create("MenuObject", "Object"));

_act_grp->add(Gtk::Action::create("MenuPath", "Path"));

_act_grp->add(Gtk::Action::create("MenuText", "Text"));

_act_grp->add(Gtk::Action::create("MenuHelp", "Help"));

// File menu

_act_grp->add(Gtk::Action::create("New",

Gtk::Stock::NEW, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onActionFileNew));

_act_grp->add(Gtk::Action::create("Open",

Gtk::Stock::OPEN, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onActionFileOpen));

_act_grp->add(Gtk::Action::create("Revert",

Gtk::Stock::REVERT_TO_SAVED, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onActionFileOpen));

_act_grp->add(Gtk::Action::create("Save",

Gtk::Stock::SAVE, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onActionFileOpen));

_act_grp->add(Gtk::Action::create("SaveAs",

Gtk::Stock::SAVE_AS, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onActionFileOpen));

_act_grp->add(Gtk::Action::create("Print",

Gtk::Stock::PRINT, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onActionFilePrint));

_act_grp->add(Gtk::Action::create("PrintPreview",

Gtk::Stock::PRINT_PREVIEW),

sigc::mem_fun(*this, &EditWidget::onActionFileOpen));

_act_grp->add(Gtk::Action::create("DocumentProperties",

Gtk::Stock::PROPERTIES, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onDialogDocumentProperties));

_act_grp->add(Gtk::Action::create("InkscapePreferences",

Gtk::Stock::PREFERENCES, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onDialogInkscapePreferences));

_act_grp->add(Gtk::Action::create("Close",

Gtk::Stock::CLOSE),

sigc::mem_fun(*this, &EditWidget::onActionFileOpen));

_act_grp->add(Gtk::Action::create("Quit",

Gtk::Stock::QUIT),

sigc::mem_fun(*this, &EditWidget::onActionFileQuit));

// EditWidget menu

_act_grp->add(Gtk::Action::create("Undo",

Gtk::Stock::UNDO, Glib::ustring(),

_("PLACEHOLDER, do not translate")));

_act_grp->add(Gtk::Action::create("Redo",

Gtk::Stock::REDO, Glib::ustring(),

_("PLACEHOLDER, do not translate")));

_act_grp->add(Gtk::Action::create("Cut",

Gtk::Stock::CUT, Glib::ustring(),

_("PLACEHOLDER, do not translate")));

_act_grp->add(Gtk::Action::create("Copy",

Gtk::Stock::COPY, Glib::ustring(),

_("PLACEHOLDER, do not translate")));

_act_grp->add(Gtk::Action::create("Paste",

Gtk::Stock::PASTE, Glib::ustring(),

_("PLACEHOLDER, do not translate")));

_act_grp->add(Gtk::Action::create("Find",

Gtk::Stock::FIND),

sigc::mem_fun(*this, &EditWidget::onDialogFind));

_act_grp->add(Gtk::Action::create("Cleanup",

Gtk::Stock::CLEAR,

_("PLACEHOLDER, do not translate")));

// Text menu

_act_grp->add(Gtk::Action::create("TextProperties",

Gtk::Stock::SELECT_FONT, Glib::ustring(),

_("PLACEHOLDER, do not translate")),

sigc::mem_fun(*this, &EditWidget::onDialogTextProperties));

// Whiteboard menu

#ifdef WITH_INKBOARD

#endif

// About menu

}

EditWidget::initToolbarActions()

{

// Tools bar

// This has zero chance to work, and has to be converted to create_with_icon_name

Gtk::RadioAction::Group tools;

// Node Controls bar

_act_grp->add(Gtk::Action::create("NodeInsert",

Gtk::Stock::ADD, Glib::ustring(),

_("PLACEHOLDER, do not translate")));

_act_grp->add(Gtk::Action::create("NodeDelete",

Gtk::Stock::REMOVE, Glib::ustring(),

_("PLACEHOLDER, do not translate")));

}

EditWidget::initAccelMap()

{

gchar *filename = g_build_filename(INKSCAPE_UIDIR, "keybindings.rc", NULL);

Gtk::AccelMap::load(filename);

g_free(filename);

// One problem is that the keys 1-6 are zoom accelerators which get

// caught as accelerator _before_ any Entry input handler receives them,

// for example the zoom status. At the moment, the best way seems to

// disable them as accelerators when the Entry gets focus, and enable

// them when focus goes elsewhere. The code for this belongs here,

// and not in zoom-status.cpp .

_zoom_status.signal_focus_in_event().connect (sigc::mem_fun (*this, &EditWidget::onEntryFocusIn));

_zoom_status.signal_focus_out_event().connect (sigc::mem_fun (*this, &EditWidget::onEntryFocusOut));

}

EditWidget::onEntryFocusIn (GdkEventFocus* /*ev*/)

{

Gdk::ModifierType m = static_cast<Gdk::ModifierType>(0);

Gtk::AccelMap::change_entry ("<Actions>//Zoom100", 0, m, false);

Gtk::AccelMap::change_entry ("<Actions>//Zoom50", 0, m, false);

Gtk::AccelMap::change_entry ("<Actions>//ZoomSelection", 0, m, false);

Gtk::AccelMap::change_entry ("<Actions>//ZoomDrawing", 0, m, false);

Gtk::AccelMap::change_entry ("<Actions>//ZoomPage", 0, m, false);

Gtk::AccelMap::change_entry ("<Actions>//ZoomWidth", 0, m, false);

return false;

}

EditWidget::onEntryFocusOut (GdkEventFocus* /*ev*/)

{

Gdk::ModifierType m = static_cast<Gdk::ModifierType>(0);

Gtk::AccelMap::change_entry ("<Actions>//Zoom100", '1', m, false);

Gtk::AccelMap::change_entry ("<Actions>//Zoom50", '2', m, false);

Gtk::AccelMap::change_entry ("<Actions>//ZoomSelection", '3', m, false);

Gtk::AccelMap::change_entry ("<Actions>//ZoomDrawing", '4', m, false);

Gtk::AccelMap::change_entry ("<Actions>//ZoomPage", '5', m, false);

Gtk::AccelMap::change_entry ("<Actions>//ZoomWidth", '6', m, false);

return false;

}

EditWidget::initMenuBar()

{

g_assert(_ui_mgr);

Gtk::MenuBar *menu = static_cast<Gtk::MenuBar*>(_ui_mgr->get_widget("/MenuBar"));

g_assert(menu != NULL);

_main_window_table.attach(*Gtk::manage(menu), 0, 1, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::SHRINK);

}

EditWidget::initCommandsBar()

{

g_assert(_ui_mgr);

Toolbox *bar = new Toolbox(static_cast<Gtk::Toolbar*>(_ui_mgr->get_widget("/CommandsBar")),

Gtk::TOOLBAR_ICONS);

g_assert(bar != NULL);

_toolbars_vbox.pack_start(*Gtk::manage(bar), Gtk::PACK_SHRINK);

}

EditWidget::initToolControlsBar()

{

// TODO: Do UIManager controlled widgets need to be deleted?

_select_ctrl = static_cast<Gtk::Toolbar*>(_ui_mgr->get_widget("/SelectControlsBar"));

_node_ctrl = static_cast<Gtk::Toolbar*>(_ui_mgr->get_widget("/NodeControlsBar"));

_tool_ctrl = new Toolbox(_select_ctrl, Gtk::TOOLBAR_ICONS);

_toolbars_vbox.pack_start(*Gtk::manage(_tool_ctrl), Gtk::PACK_SHRINK);

}

EditWidget::initUriBar()

{

/// \todo Create an Inkscape::UI::Widget::UriBar class (?)

_uri_ctrl = new Gtk::Toolbar();

_uri_label.set_label(_("PLACEHOLDER, do not translate"));

_uri_ctrl->add(_uri_label);

_uri_ctrl->add(_uri_entry);

_uri_entry.signal_activate()

.connect_notify(sigc::mem_fun(*this, &EditWidget::onUriChanged));

_toolbars_vbox.pack_start(*Gtk::manage(_uri_ctrl), Gtk::PACK_SHRINK);

}

EditWidget::initToolsBar()

{

Toolbox *bar = new Toolbox(static_cast<Gtk::Toolbar*>(_ui_mgr->get_widget("/ToolsBar")),

Gtk::TOOLBAR_ICONS,

Gtk::ORIENTATION_VERTICAL);

g_assert(bar != NULL);

_sub_window_hbox.pack_start(*Gtk::manage(bar), Gtk::PACK_SHRINK);

}

EditWidget::initTopRuler()

{

_viewport_table.attach(_top_ruler, 1, 2, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::SHRINK);

_tooltips.set_tip (_top_ruler, _top_ruler.get_tip());

}

EditWidget::initLeftRuler()

{

_viewport_table.attach(_left_ruler, 0, 1, 1, 2, Gtk::SHRINK, Gtk::FILL|Gtk::EXPAND);

_tooltips.set_tip (_left_ruler, _left_ruler.get_tip());

}

EditWidget::initBottomScrollbar()

{

_viewport_table.attach(_bottom_scrollbar, 1, 2, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::SHRINK);

_bottom_scrollbar.signal_value_changed().connect (sigc::mem_fun (*this, &EditWidget::onAdjValueChanged));

_bottom_scrollbar.property_adjustment() = new Gtk::Adjustment (0.0, -4000.0, 4000.0, 10.0, 100.0, 4.0);

}

EditWidget::initRightScrollbar()

{

_viewport_table.attach(_right_scrollbar, 2, 3, 1, 2, Gtk::SHRINK, Gtk::FILL|Gtk::EXPAND);

_right_scrollbar.signal_value_changed().connect (sigc::mem_fun (*this, &EditWidget::onAdjValueChanged));

_right_scrollbar.property_adjustment() = new Gtk::Adjustment (0.0, -4000.0, 4000.0, 10.0, 100.0, 4.0);

}

EditWidget::initStickyZoom()

{

Inkscape::Preferences *prefs = Inkscape::Preferences::get();

_viewport_table.attach(_sticky_zoom, 2, 3, 0, 1, Gtk::SHRINK, Gtk::SHRINK);

_sticky_zoom.set_active (prefs->getBool("/options/stickyzoom/value"));

_tooltips.set_tip (_sticky_zoom, _("Zoom drawing if window size changes"));

/// \todo icon not implemented

}

EditWidget::initStatusbar()

{

_statusbar.pack_start (_selected_style_status, false, false, 1);

_statusbar.pack_start (*new Gtk::VSeparator(), false, false, 0);

_tooltips.set_tip (_zoom_status, _("Zoom"));

_layer_selector.reference();

_statusbar.pack_start (_layer_selector, false, false, 1);

_coord_status.property_n_rows() = 2;

_coord_status.property_n_columns() = 5;

_coord_status.property_row_spacing() = 0;

_coord_status.property_column_spacing() = 2;

_coord_eventbox.add (_coord_status);

_tooltips.set_tip (_coord_eventbox, _("Cursor coordinates"));

_coord_status.attach (*new Gtk::VSeparator(), 0,1, 0,2, Gtk::FILL,Gtk::FILL, 0,0);

_coord_status.attach (*new Gtk::Label("X:", 0.0, 0.5), 1,2, 0,1, Gtk::FILL,Gtk::FILL, 0,0);

_coord_status.attach (*new Gtk::Label("Y:", 0.0, 0.5), 1,2, 1,2, Gtk::FILL,Gtk::FILL, 0,0);

_coord_status_x.set_text ("0.0");

_coord_status_x.set_alignment (0.0, 0.5);

_coord_status_y.set_text ("0.0");

_coord_status_y.set_alignment (0.0, 0.5);

_coord_status.attach (_coord_status_x, 2,3, 0,1, Gtk::FILL,Gtk::FILL, 0,0);

_coord_status.attach (_coord_status_y, 2,3, 1,2, Gtk::FILL,Gtk::FILL, 0,0);

_coord_status.attach (*new Gtk::Label("Z:", 0.0, 0.5), 3,4, 0,2, Gtk::FILL,Gtk::FILL, 0,0);

_coord_status.attach (_zoom_status, 4,5, 0,2, Gtk::FILL,Gtk::FILL, 0,0);

sp_set_font_size_smaller (static_cast<GtkWidget*>((void*)_coord_status.gobj()));

_statusbar.pack_end (_coord_eventbox, false, false, 1);

_select_status.property_xalign() = 0.0;

_select_status.property_yalign() = 0.5;

_select_status.set_markup (_("<b>Welcome to Inkscape!</b> Use shape or drawing tools to create objects; use selector (arrow) to move or transform them."));

// include this again with Gtk+-2.6

#if GTK_VERSION_GE(2,6)

gtk_label_set_ellipsize (GTK_LABEL(_select_status.gobj()), PANGO_ELLIPSIZE_END);

#endif

_select_status.set_size_request (1, -1);

_statusbar.pack_start (_select_status, true, true, 0);

_main_window_table.attach(_statusbar, 0, 1, 3, 4, Gtk::FILL, Gtk::SHRINK);

}

Gtk::Window *

EditWidget::getWindow()

{

return this;

}

EditWidget::setTitle (gchar const* new_title)

{

set_title (new_title);

}

EditWidget::layout()

{

show_all_children();

}

EditWidget::present()

{

this->Gtk::Window::present();

}

EditWidget::getGeometry (gint &x, gint &y, gint &w, gint &h)

{

get_position (x, y);

get_size (w, h);

}

EditWidget::setSize (gint w, gint h)

{

resize (w, h);

}

EditWidget::setPosition (Geom::Point p)

{

move (int(p[Geom::X]), int(p[Geom::Y]));

}

EditWidget::setTransient (void* p, int i)

{

gtk_window_set_transient_for (static_cast<GtkWindow*>(p), this->gobj());

if (i==2)

this->Gtk::Window::present();

}

Geom::Point

EditWidget::getPointer()

{

int x, y;

get_pointer (x, y);

return Geom::Point (x, y);

}

EditWidget::setIconified()

{

iconify();

}

EditWidget::setMaximized()

{

maximize();

}

EditWidget::setFullscreen()

{

fullscreen();

}

EditWidget::shutdown()

{

g_assert (_desktop != NULL);

if (Inkscape::NSApplication::Editor::isDuplicatedView (_desktop))

return false;

SPDocument *doc = _desktop->doc();

if (doc->isModifiedSinceSave()) {

gchar *markup;

/// \todo FIXME !!! obviously this will have problems if the document

/// name contains markup characters

markup = g_strdup_printf(

_("<span weight=\"bold\" size=\"larger\">Save changes to document \"%s\" before closing?</span>\n\n"

"If you close without saving, your changes will be discarded."),

SP_DOCUMENT_NAME(doc));

Gtk::MessageDialog dlg (*this,

markup,

true,

Gtk::MESSAGE_WARNING,

Gtk::BUTTONS_NONE,

true);

g_free(markup);

Gtk::Button close_button (_("Close _without saving"), true);

dlg.add_action_widget (close_button, Gtk::RESPONSE_NO);

close_button.show();

dlg.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

dlg.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_YES);

dlg.set_default_response (Gtk::RESPONSE_YES);

int response = dlg.run();

switch (response)

{

case Gtk::RESPONSE_YES:

sp_document_ref(doc);

if (sp_file_save_document(*this, 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

return TRUE;

break;

}

}

/* Code to check data loss */

bool allow_data_loss = FALSE;

while (sp_document_repr_root(doc)->attribute("inkscape:dataloss") != NULL && allow_data_loss == FALSE)

{

gchar *markup;

/// \todo FIXME !!! obviously this will have problems if the document

/// name contains markup characters

markup = g_strdup_printf(

_("<span weight=\"bold\" size=\"larger\">The file \"%s\" was saved with a format (%s) that may cause data loss!</span>\n\n"

"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());

Gtk::MessageDialog dlg (*this,

markup,

true,

Gtk::MESSAGE_WARNING,

Gtk::BUTTONS_NONE,

true);

g_free(markup);

Gtk::Button close_button (_("Close _without saving"), true);

dlg.add_action_widget (close_button, Gtk::RESPONSE_NO);

close_button.show();

Gtk::Button save_button (_("_Save as SVG"), true);

dlg.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

dlg.add_action_widget (save_button, Gtk::RESPONSE_YES);

save_button.show();

dlg.set_default_response (Gtk::RESPONSE_YES);

int response = dlg.run();

switch (response)

{

case Gtk::RESPONSE_YES:

sp_document_ref(doc);

if (sp_file_save_document(*this, 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;

default: // cancel pressed, or dialog was closed

return TRUE;

break;

}

}

return false;

}

EditWidget::destroy()

{

delete this;

}

EditWidget::requestCanvasUpdate()

{

_svg_canvas.widget().queue_draw();

}

EditWidget::requestCanvasUpdateAndWait()

{

requestCanvasUpdate();

while (gtk_events_pending())

gtk_main_iteration_do(FALSE);

}

EditWidget::enableInteraction()

{

g_return_if_fail(_interaction_disabled_counter > 0);

_interaction_disabled_counter--;

if (_interaction_disabled_counter == 0) {

this->set_sensitive(true);

}

}

EditWidget::disableInteraction()

{

if (_interaction_disabled_counter == 0) {

this->set_sensitive(false);

}

_interaction_disabled_counter++;

}

EditWidget::activateDesktop()

{

/// \todo active_desktop_indicator not implemented

}

EditWidget::deactivateDesktop()

{

/// \todo active_desktop_indicator not implemented

}

EditWidget::viewSetPosition (Geom::Point p)

{

// p -= _namedview->gridorigin;

/// \todo Why was the origin corrected for the grid origin? (johan)

double lo, up, pos, max;

_top_ruler.get_range (lo, up, pos, max);

_top_ruler.set_range (lo, up, p[Geom::X], max);

_left_ruler.get_range (lo, up, pos, max);

_left_ruler.set_range (lo, up, p[Geom::Y], max);

}

EditWidget::updateRulers()

{

//Geom::Point gridorigin = _namedview->gridorigin;

/// \todo Why was the origin corrected for the grid origin? (johan)

Geom::Rect const viewbox = _svg_canvas.spobj()->getViewbox();

double lo, up, pos, max;

double const scale = _desktop->current_zoom();

double s = viewbox.min()[Geom::X] / scale; //- gridorigin[Geom::X];

double e = viewbox.max()[Geom::X] / scale; //- gridorigin[Geom::X];

_top_ruler.get_range(lo, up, pos, max);

_top_ruler.set_range(s, e, pos, e);

s = viewbox.min()[Geom::Y] / -scale; //- gridorigin[Geom::Y];

e = viewbox.max()[Geom::Y] / -scale; //- gridorigin[Geom::Y];

_left_ruler.set_range(s, e, 0 /*gridorigin[Geom::Y]*/, e);

/// \todo is that correct?

}

EditWidget::updateScrollbars (double scale)

{

// do not call this function before canvas has its size allocated

if (!is_realized() || _update_s_f) {

return;

}

_update_s_f = true;

/* The desktop region we always show unconditionally */

SPDocument *doc = _desktop->doc();

Geom::Rect darea ( Geom::Point(-sp_document_width(doc), -sp_document_height(doc)),

Geom::Point(2 * sp_document_width(doc), 2 * sp_document_height(doc)) );

SPObject* root = doc->root;

SPItem* item = SP_ITEM(root);

Geom::OptRect deskarea = Geom::unify(darea, sp_item_bbox_desktop(item));

/* Canvas region we always show unconditionally */

Geom::Rect carea( Geom::Point(deskarea->min()[Geom::X] * scale - 64, deskarea->max()[Geom::Y] * -scale - 64),

Geom::Point(deskarea->max()[Geom::X] * scale + 64, deskarea->min()[Geom::Y] * -scale + 64) );

Geom::Rect const viewbox = _svg_canvas.spobj()->getViewbox();

/* Viewbox is always included into scrollable region */

carea = Geom::unify(carea, viewbox);

Gtk::Adjustment *adj = _bottom_scrollbar.get_adjustment();

adj->set_value(viewbox.min()[Geom::X]);

adj->set_lower(carea.min()[Geom::X]);

adj->set_upper(carea.max()[Geom::X]);

adj->set_page_increment(viewbox.dimensions()[Geom::X]);

adj->set_step_increment(0.1 * (viewbox.dimensions()[Geom::X]));

adj->set_page_size(viewbox.dimensions()[Geom::X]);

adj = _right_scrollbar.get_adjustment();

adj->set_value(viewbox.min()[Geom::Y]);

adj->set_lower(carea.min()[Geom::Y]);

adj->set_upper(carea.max()[Geom::Y]);

adj->set_page_increment(viewbox.dimensions()[Geom::Y]);

adj->set_step_increment(0.1 * viewbox.dimensions()[Geom::Y]);

adj->set_page_size(viewbox.dimensions()[Geom::Y]);

_update_s_f = false;

}

EditWidget::toggleRulers()

{

Inkscape::Preferences *prefs = Inkscape::Preferences::get();

if (_top_ruler.is_visible())

{

_top_ruler.hide_all();

_left_ruler.hide_all();

prefs->setBool(_desktop->is_fullscreen() ? "/fullscreen/rulers/state" : "/window/rulers/state", false);

} else {

_top_ruler.show_all();

_left_ruler.show_all();

prefs->setBool(_desktop->is_fullscreen() ? "/fullscreen/rulers/state" : "/window/rulers/state", true);

}

}

EditWidget::toggleScrollbars()

{

Inkscape::Preferences *prefs = Inkscape::Preferences::get();

if (_bottom_scrollbar.is_visible())

{

_bottom_scrollbar.hide_all();

_right_scrollbar.hide_all();

prefs->setBool(_desktop->is_fullscreen() ? "/fullscreen/scrollbars/state" : "/window/scrollbars/state", false);

} else {

_bottom_scrollbar.show_all();

_right_scrollbar.show_all();

prefs->setBool(_desktop->is_fullscreen() ? "/fullscreen/scrollbars/state" : "/window/scrollbars/state", true);

}

}

void EditWidget::toggleColorProfAdjust()

{

// TODO implement

}

EditWidget::updateZoom()

{

_zoom_status.update();

}

EditWidget::letZoomGrabFocus()

{

_zoom_status.grab_focus();

}

EditWidget::setToolboxFocusTo (const gchar *)

{

/// \todo not implemented

}

EditWidget::setToolboxAdjustmentValue (const gchar *, double)

{

/// \todo not implemented

}

EditWidget::setToolboxSelectOneValue (const gchar *, gint)

{

/// \todo not implemented

}

EditWidget::isToolboxButtonActive (gchar const*)

{

/// \todo not implemented

return true;

}

EditWidget::setCoordinateStatus (Geom::Point p)

{

gchar *cstr = g_strdup_printf ("%6.2f", _dt2r * p[Geom::X]);

_coord_status_x.property_label() = cstr;

g_free (cstr);

cstr = g_strdup_printf ("%6.2f", _dt2r * p[Geom::Y]);

_coord_status_y.property_label() = cstr;

g_free (cstr);

}

EditWidget::setMessage (Inkscape::MessageType /*type*/, gchar const* msg)

{

_select_status.set_markup (msg? msg : "");

}

EditWidget::warnDialog (gchar* msg)

{

Gtk::MessageDialog dlg (*this,

msg,

true,

Gtk::MESSAGE_WARNING,

Gtk::BUTTONS_YES_NO,

true);

int r = dlg.run();

return r == Gtk::RESPONSE_YES;

}

Inkscape::UI::Widget::Dock*

EditWidget::getDock ()

{

return &_dock;

}

void EditWidget::_namedview_modified (SPObject *obj, guint flags) {

SPNamedView *nv = static_cast<SPNamedView *>(obj);

if (flags & SP_OBJECT_MODIFIED_FLAG) {

this->_dt2r = 1.0 / nv->doc_units->unittobase;

this->_top_ruler.update_metric();

this->_left_ruler.update_metric();

this->_tooltips.set_tip(this->_top_ruler, this->_top_ruler.get_tip());

this->_tooltips.set_tip(this->_left_ruler, this->_left_ruler.get_tip());

this->updateRulers();

}

}

EditWidget::initEdit (SPDocument *doc)

{

_desktop = new SPDesktop();

_desktop->registerEditWidget (this);

_namedview = sp_document_namedview (doc, 0);

_svg_canvas.init (_desktop);

_desktop->init (_namedview, _svg_canvas.spobj());

sp_namedview_window_from_document (_desktop);

sp_namedview_update_layers_from_document (_desktop);

_dt2r = 1.0 / _namedview->doc_units->unittobase;

/// \todo convert to sigc++ when SPObject hierarchy gets converted

/* Listen on namedview modification */

_namedview_modified_connection = _desktop->namedview->connectModified(sigc::mem_fun(*this, &EditWidget::_namedview_modified));

_layer_selector.setDesktop (_desktop);

_selected_style_status.setDesktop (_desktop);

Inkscape::NSApplication::Editor::addDesktop (_desktop);

_zoom_status.init (_desktop);

_top_ruler.init (_desktop, _svg_canvas.widget());

_left_ruler.init (_desktop, _svg_canvas.widget());

updateRulers();

}

EditWidget::destroyEdit()

{

if (_desktop) {

_layer_selector.unreference();

Inkscape::NSApplication::Editor::removeDesktop (_desktop); // clears selection too

_namedview_modified_connection.disconnect();

_desktop->destroy();

Inkscape::GC::release (_desktop);

_desktop = 0;

}

}

EditWidget::on_key_press_event (GdkEventKey* event)

{

// this is the original code from helper/window.cpp

unsigned int shortcut;

shortcut = get_group0_keyval (event) |

( event->state & GDK_SHIFT_MASK ?

SP_SHORTCUT_SHIFT_MASK : 0 ) |

( event->state & GDK_CONTROL_MASK ?

SP_SHORTCUT_CONTROL_MASK : 0 ) |

( event->state & GDK_MOD1_MASK ?

SP_SHORTCUT_ALT_MASK : 0 );

return sp_shortcut_invoke (shortcut,

Inkscape::NSApplication::Editor::getActiveDesktop());

}

EditWidget::on_delete_event (GdkEventAny*)

{

return shutdown();

}

EditWidget::on_focus_in_event (GdkEventFocus*)

{

Inkscape::NSApplication::Editor::activateDesktop (_desktop);

_svg_canvas.widget().grab_focus();

return false;

}

EditWidget::onWindowSizeAllocate (Gtk::Allocation &newall)

{

if (!is_realized()) return;

const Gtk::Allocation& all = get_allocation();

if ((newall.get_x() == all.get_x()) &&

(newall.get_y() == all.get_y()) &&

(newall.get_width() == all.get_width()) &&

(newall.get_height() == all.get_height())) {

return;

}

Geom::Rect const area = _desktop->get_display_area();

double zoom = _desktop->current_zoom();

if (_sticky_zoom.get_active()) {

/* Calculate zoom per pixel */

double const zpsp = zoom / hypot(area.dimensions()[Geom::X], area.dimensions()[Geom::Y]);

/* Find new visible area */

Geom::Rect const newarea = _desktop->get_display_area();

/* Calculate adjusted zoom */

zoom = zpsp * hypot(newarea.dimensions()[Geom::X], newarea.dimensions()[Geom::Y]);

}

_desktop->zoom_absolute(area.midpoint()[Geom::X], area.midpoint()[Geom::Y], zoom);

}

EditWidget::onWindowRealize()

{

if ( (sp_document_width(_desktop->doc()) < 1.0) || (sp_document_height(_desktop->doc()) < 1.0) ) {

return;

}

Geom::Rect d( Geom::Point(0, 0),

Geom::Point(sp_document_width(_desktop->doc()), sp_document_height(_desktop->doc())) );

_desktop->set_display_area(d.min()[Geom::X], d.min()[Geom::Y], d.max()[Geom::X], d.max()[Geom::Y], 10);

_namedview_modified(_desktop->namedview, SP_OBJECT_MODIFIED_FLAG);

setTitle (SP_DOCUMENT_NAME(_desktop->doc()));

}

EditWidget::onAdjValueChanged()

{

if (_update_a_f) return;

_update_a_f = true;

sp_canvas_scroll_to (_svg_canvas.spobj(),

_bottom_scrollbar.get_value(),

_right_scrollbar.get_value(),

false);

updateRulers();

_update_a_f = false;

}

} // namespace View

} // namespace UI

} // namespace Inkscape