document.cpp revision 209527815f6ad1b81d21bb3188947aef3d845010
#define __SP_DOCUMENT_C__
/** \file
* SPDocument manipulation
*
* Authors:
* Lauris Kaplinski <lauris@kaplinski.com>
* MenTaLguY <mental@rydia.net>
* bulia byak <buliabyak@users.sf.net>
*
* Copyright (C) 2004-2005 MenTaLguY
* Copyright (C) 1999-2002 Lauris Kaplinski
* Copyright (C) 2000-2001 Ximian, Inc.
*
* Released under GNU GPL, read the file 'COPYING' for more information
*/
/** \class SPDocument
* SPDocument serves as the container of both model trees (agnostic XML
* and typed object tree), and implements all of the document-level
* functionality used by the program. Many document level operations, like
* load, save, print, export and so on, use SPDocument as their basic datatype.
*
* SPDocument implements undo and redo stacks and an id-based object
* dictionary. Thanks to unique id attributes, the latter can be used to
* map from the XML tree back to the object tree.
*
* SPDocument performs the basic operations needed for asynchronous
* update notification (SPObject ::modified virtual method), and implements
* the 'modified' signal, as well.
*/
#define noSP_DOCUMENT_DEBUG_IDLE
#define noSP_DOCUMENT_DEBUG_UNDO
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "application/application.h"
#include "application/editor.h"
#include "libnr/nr-matrix-fns.h"
#include "inkscape-private.h"
#include "inkscape_version.h"
#include "sp-object-repr.h"
#include "document-private.h"
#include "dir-util.h"
#include "unit-constants.h"
#include "prefs-utils.h"
#include "sp-item-group.h"
#include "perspective3d.h"
#include "display/nr-arena-item.h"
#define A4_WIDTH_STR "210mm"
#define A4_HEIGHT_STR "297mm"
static unsigned long next_serial = 0;
SPDocument::SPDocument() {
modified_id = 0;
// Initialise instance of connector router.
// Don't use the Consolidate moves optimisation.
router->ConsolidateMoves = false;
perspectives = NULL;
/* Create an initial perspective, make it current and append it to the list of existing perspectives */
// VP in x-direction
// VP in y-direction
// VP in z-direction
this);
p = new SPDocumentPrivate();
p->serial = next_serial++;
p->history_size = 0;
p->seeking = false;
priv = p;
// XXX only for testing!
}
SPDocument::~SPDocument() {
if (priv) {
}
sp_document_clear_redo(this);
sp_document_clear_undo(this);
if (root) {
}
/* Free resources */
delete priv;
}
if (name) {
}
if (base) {
}
if (uri) {
}
if (modified_id) {
modified_id = 0;
}
if (keepalive) {
}
if (router) {
delete router;
}
//delete this->_whiteboard_session_manager;
// TODO: Do we have to delete the perspectives?
/***
for (GSList *i = perspectives; i != NULL; ++i) {
delete ((Box3D::Perspective3D *) i->data);
}
g_slist_free (perspectives);
***/
}
{
// FIXME: Should we handle the case that the perspectives have equal VPs but are not identical?
// If so, we need to take care of relinking the boxes, etc.
}
{
}
// find an existing perspective whose VPs are equal to those of persp
{
}
}
return NULL; // perspective was not found
}
{
}
g_warning ("Stray 3D box!\n");
}
{
return persp;
}
g_warning ("Stray vanishing point!\n");
}
unsigned long SPDocument::serial() const {
}
}
void SPDocument::collectOrphans() {
while (_collection_queue) {
object->collectOrphan();
}
}
}
{
}
unsigned int keepalive)
{
document = new SPDocument();
#ifndef WIN32
#else
// FIXME: it may be that prepend_current_dir_if_relative works OK on windows too, test!
#endif
// base is simply the part of the path before filename; e.g. when running "inkscape ../file.svg" the base is "../"
// which is why we use g_get_current_dir() in calculating the abs path above
//This is NULL for a new document
if (base)
else
/* fixme: Not sure about this, but lets assume ::build updates */
/* fixme: Again, I moved these here to allow version determining in ::build (Lauris) */
/* Quick hack 2 - get default image size into document */
/* End of quick hack 2 */
/* Quick hack 3 - Set uri attributes */
if (uri) {
}
/* End of quick hack 3 */
// creating namedview
// if there's none in the document already,
// see if there's a template with id="base" in the preferences
if (!r) {
// if there's none, create an empty element
} else {
// otherwise, take from preferences
}
// insert into the document
// clean up
}
/* Defs */
}
/* Default RDF */
if (keepalive) {
inkscape_ref();
}
// reset undo key when selection changes, so that same-key actions on different objects are not coalesced
} else {
document->_selection_changed_connection = Inkscape::NSApplication::Editor::connectSelectionChanged (sigc::mem_fun (*document, &SPDocument::reset_key));
document->_desktop_activated_connection = Inkscape::NSApplication::Editor::connectDesktopActivated (sigc::mem_fun (*document, &SPDocument::reset_key));
}
return document;
}
/**
* Fetches document from URI, or creates new, if NULL; public document
* appears in document list.
*/
{
if (uri) {
gchar *s, *p;
/* Try to fetch repr from file */
/* If file cannot be loaded, return NULL without warning */
/* If xml file is not svg, return NULL without warning */
/* fixme: destroy document */
p = strrchr(s, '/');
if (p) {
p[1] = '\0';
} else {
}
g_free(s);
} else {
}
if (make_new) {
}
//# These should be set by now
return doc;
}
{
/* If it cannot be loaded, return NULL without warning */
/* If xml file is not svg, return NULL without warning */
/* fixme: destroy document */
return doc;
}
{
return doc;
}
{
return NULL;
}
{
}
void
{
} else { // set to width=
/* SVG does not support meters as a unit, so we must translate meters to
* cm when writing */
} else {
}
}
}
{
} else { // set to height=
/* SVG does not support meters as a unit, so we must translate meters to
* cm when writing */
} else {
}
}
}
{
}
/**
* Given an NR::Rect that may, for example, correspond to the bbox of an object,
* this function fits the canvas to that rect by resizing the canvas
* and translating the document root into position.
*/
{
double const old_height = sp_document_height(this);
sp_document_set_width(this, w, &px);
sp_document_set_height(this, h, &px);
}
{
}
}
}
if (uri) {
#ifndef WIN32
#else
// FIXME: it may be that prepend_current_dir_if_relative works OK on windows too, test!
#endif
/* fixme: Think, what this means for images (Lauris) */
} else {
}
// Update saveable repr attributes.
// changing uri in the document repr must not be not undoable
sp_document_set_undo_sensitive(document, false);
}
void
{
}
{
}
{
}
{
}
{
}
void
{
// printf("Starting Reconstruction\n");
return;
}
{
}
void
{
// printf("Finishing Reconstruction\n");
return;
}
{
}
void SPDocument::_emitModified() {
static guint const flags = SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG;
root->emitModified(0);
}
if (object) {
} else {
}
} else { // discard unused signal
}
}
}
void
{
}
void
{
}
}
{
}
if (object) {
} else {
}
}
}
if (document_language) {
while (isspace(*document_language))
}
if ( !document_language || 0 == *document_language) {
// retrieve system language
}
}
if ( NULL != document_language ) {
}
}
}
if ( NULL == document_language )
return document_language;
}
/* Object modification root handler */
void
{
if (!doc->modified_id) {
doc->modified_id = gtk_idle_add_priority(SP_DOCUMENT_UPDATE_PRIORITY, sp_document_idle_handler, doc);
}
}
void
{
/* Set up viewport in case svg has it defined as percentages */
} else { // as a last resort, set size to A4
}
}
/**
* Tries to update the document state based on the modified and
* "update required" flags, and return true if the document has
* been brought fully up to date.
*/
bool
{
/* Process updates */
sp_document_setup_viewport (this, &ctx);
bool saved = sp_document_get_undo_sensitive(this);
sp_document_set_undo_sensitive(this, false);
sp_document_set_undo_sensitive(this, saved);
}
this->_emitModified();
}
}
/**
* Repeatedly works on getting the document updated, since sometimes
* it takes more than one pass to get the document updated. But it
* usually should not take more than a few loops, and certainly never
* more than 32 iterations. So we bail out if we hit 32 iterations,
* since this typically indicates we're stuck in an update loop.
*/
{
int counter = 32;
while (!doc->_updateDocument()) {
if (counter == 0) {
break;
}
counter--;
}
if (doc->modified_id) {
/* Remove handler */
doc->modified_id = 0;
}
return counter>0;
}
/**
* An idle handler to update the document. Returns true if
* the document needs further updates.
*/
static gint
{
if (doc->_updateDocument()) {
doc->modified_id = 0;
return false;
} else {
return true;
}
}
{
}
{
}
static GSList *find_items_in_area(GSList *s, SPGroup *group, unsigned int dkey, NR::Rect const &area,
{
if (!SP_IS_ITEM(o)) {
continue;
}
} else {
s = g_slist_append(s, child);
}
}
}
return s;
}
/**
Returns true if an item is among the descendants of group (recursively).
*/
{
if (!SP_IS_ITEM(o)) continue;
return true;
if (SP_IS_GROUP(o))
return true;
}
return false;
}
/**
Returns the bottommost item from the list which is at the point, or NULL if none.
*/
{
if (!SP_IS_ITEM(o)) continue;
return item;
}
if (SP_IS_GROUP(o)) {
SPItem *found = sp_document_item_from_list_at_point_bottom(dkey, SP_GROUP(o), list, p, take_insensitive);
if (found)
return found;
}
}
return NULL;
}
/**
Returns the topmost (in z-order) item from the descendants of group (recursively) which
is at the point p, or NULL if none. Honors into_groups on whether to recurse into
non-layer groups or not. Honors take_insensitive on whether to return insensitive
items. If upto != NULL, then if item upto is encountered (at any level), stops searching
upwards in z-order and returns what it has found so far (i.e. the found item is
guaranteed to be lower than upto).
*/
find_item_at_point(unsigned int dkey, SPGroup *group, NR::Point const p, gboolean into_groups, bool take_insensitive = false, SPItem *upto = NULL)
{
if (!SP_IS_ITEM(o)) continue;
break;
// if nothing found yet, recurse into the group
if (newseen) {
}
break;
} else {
// seen remembers the last (topmost) of items pickable at this point
}
}
}
return seen;
}
/**
Returns the topmost non-layer group from the descendants of group which is at point
p, or NULL if none. Recurses into layers but not into groups.
*/
{
if (!SP_IS_ITEM(o)) continue;
if (newseen) {
}
}
// seen remembers the last (topmost) of groups pickable at this point
}
}
}
return seen;
}
/*
* Return list of items, contained in box
*
* Assumes box is normalized (and g_asserts it!)
*
*/
{
}
/*
* Return list of items, that the parts of the item contained in box
*
* Assumes box is normalized (and g_asserts it!)
*
*/
GSList *sp_document_partial_items_in_box(SPDocument *document, unsigned int dkey, NR::Rect const &box)
{
}
GSList *
sp_document_items_at_points(SPDocument *document, unsigned const key, std::vector<NR::Point> points)
{
// When picking along the path, we don't want small objects close together
// (such as hatching strokes) to obscure each other by their deltas,
// so we temporarily set delta to a small value
false, NULL);
}
// and now we restore it back
return items;
}
SPItem *
{
}
{
}
/* Resource management */
{
if (SP_OBJECT_IS_CLONED(object))
return FALSE;
return TRUE;
}
{
if (SP_OBJECT_IS_CLONED(object))
return FALSE;
return TRUE;
}
GSList const *
{
}
{
}
/* Helpers */
{
return TRUE;
}
unsigned int
{
count++; // obj itself
}
return count;
}
unsigned int
{
}
void
{
if (SP_IS_DEFS(obj)) {
/* fixme: some inkscape-internal nodes in the future might not be collectable */
}
} else {
}
}
}
unsigned int
{
unsigned int end;
unsigned int iterations = 0;
do {
iterations++;
}
bool SPDocument::isSeeking() const {
}
/*
Local Variables:
mode:c++
c-file-style:"stroustrup"
c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
indent-tabs-mode:nil
fill-column:99
End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :