static void
sp_clippath_modified(SPObject *object, guint flags)
{
if (flags & SP_OBJECT_MODIFIED_FLAG) {
flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
}
flags &= SP_OBJECT_MODIFIED_CASCADE;
SPObjectGroup *og = SP_OBJECTGROUP(object);
GSList *l = NULL;
for (SPObject *child = sp_object_first_child(SP_OBJECT(og)); child != NULL; child = SP_OBJECT_NEXT(child)) {
g_object_ref(G_OBJECT(child));
l = g_slist_prepend(l, child);
}
l = g_slist_reverse(l);
while (l) {
SPObject *child = SP_OBJECT(l->data);
l = g_slist_remove(l, child);
if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
child->emitModified(flags);
}
g_object_unref(G_OBJECT(child));
}
}
static void
sp_item_create_link(GtkMenuItem *menuitem, SPItem *item)
{
g_assert(SP_IS_ITEM(item));
g_assert(!SP_IS_ANCHOR(item));
SPDesktop *desktop = (SPDesktop*)gtk_object_get_data(GTK_OBJECT(menuitem), "desktop");
g_return_if_fail(desktop != NULL);
Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
Inkscape::XML::Node *repr = xml_doc->createElement("svg:a");
SP_OBJECT_REPR(SP_OBJECT_PARENT(item))->addChild(repr, SP_OBJECT_REPR(item));
SPObject *object = SP_OBJECT_DOCUMENT(item)->getObjectByRepr(repr);
g_return_if_fail(SP_IS_ANCHOR(object));
const char *id = SP_OBJECT_REPR(item)->attribute("id");
Inkscape::XML::Node *child = SP_OBJECT_REPR(item)->duplicate(xml_doc);
SP_OBJECT(item)->deleteObject(false);
repr->addChild(child, NULL);
child->setAttribute("id", id);
Inkscape::GC::release(repr);
Inkscape::GC::release(child);
sp_document_done(SP_OBJECT_DOCUMENT(object), SP_VERB_NONE,
_("Create link"));
sp_object_attributes_dialog(object, "SPAnchor");
sp_desktop_selection(desktop)->set(SP_ITEM(object));
}
void ColorICCSelector::_profilesChanged( std::string const & name )
{
GtkComboBox* combo = GTK_COMBO_BOX(_profileSel);
g_signal_handler_block( G_OBJECT(_profileSel), _profChangedID );
GtkListStore *store = (GtkListStore *)gtk_combo_box_get_model (combo);
gtk_list_store_clear(store);
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("<none>"), 1, _("<none>"), -1);
gtk_combo_box_set_active( combo, 0 );
int index = 1;
const GSList *current = SP_ACTIVE_DOCUMENT->getResourceList( "iccprofile" );
while ( current ) {
SPObject* obj = SP_OBJECT(current->data);
Inkscape::ColorProfile* prof = reinterpret_cast<Inkscape::ColorProfile*>(obj);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, gr_ellipsize_text(prof->name, 25).c_str(), 1, prof->name, -1);
if ( name == prof->name ) {
gtk_combo_box_set_active( combo, index );
gtk_widget_set_tooltip_text(_profileSel, prof->name );
}
index++;
current = g_slist_next(current);
}
g_signal_handler_unblock( G_OBJECT(_profileSel), _profChangedID );
}
void
sp_textpath_to_text(SPObject *tp)
{
SPObject *text = SP_OBJECT_PARENT(tp);
NRRect bbox;
sp_item_invoke_bbox(SP_ITEM(text), &bbox, sp_item_i2doc_affine(SP_ITEM(text)), TRUE);
Geom::Point xy(bbox.x0, bbox.y0);
// make a list of textpath children
GSList *tp_reprs = NULL;
for (SPObject *o = SP_OBJECT(tp)->firstChild() ; o != NULL; o = o->next) {
tp_reprs = g_slist_prepend(tp_reprs, SP_OBJECT_REPR(o));
}
for ( GSList *i = tp_reprs ; i ; i = i->next ) {
// make a copy of each textpath child
Inkscape::XML::Node *copy = ((Inkscape::XML::Node *) i->data)->duplicate(SP_OBJECT_REPR(text)->document());
// remove the old repr from under textpath
SP_OBJECT_REPR(tp)->removeChild((Inkscape::XML::Node *) i->data);
// put its copy under text
SP_OBJECT_REPR(text)->addChild(copy, NULL); // fixme: copy id
}
//remove textpath
tp->deleteObject();
g_slist_free(tp_reprs);
// set x/y on text
/* fixme: Yuck, is this really the right test? */
if (xy[Geom::X] != 1e18 && xy[Geom::Y] != 1e18) {
sp_repr_set_svg_double(SP_OBJECT_REPR(text), "x", xy[Geom::X]);
sp_repr_set_svg_double(SP_OBJECT_REPR(text), "y", xy[Geom::Y]);
}
}
//FIXME: must work with text selection
void
text_remove_all_kerns()
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
Inkscape::Selection *selection = sp_desktop_selection(desktop);
if (selection->isEmpty()) {
sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>text(s)</b> to remove kerns from."));
return;
}
bool did = false;
for (GSList *items = g_slist_copy((GSList *) selection->itemList());
items != NULL;
items = items->next) {
SPObject *obj = SP_OBJECT(items->data);
if (!SP_IS_TEXT(obj) && !SP_IS_TSPAN(obj) && !SP_IS_FLOWTEXT(obj)) {
continue;
}
text_remove_all_kerns_recursively(obj);
obj->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_TEXT_LAYOUT_MODIFIED_FLAG);
did = true;
}
if (!did) {
sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE, _("Select <b>text(s)</b> to remove kerns from."));
} else {
sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_TEXT,
_("Remove manual kerns"));
}
}
static void
sp_fill_style_get_average_color_cmyka (const GSList *objects, gfloat *c)
{
gint num;
c[0] = 0.0;
c[1] = 0.0;
c[2] = 0.0;
c[3] = 0.0;
c[4] = 0.0;
num = 0;
while (objects) {
SPObject *object;
gfloat d[4];
object = SP_OBJECT (objects->data);
if (object->style->fill.type == SP_PAINT_TYPE_COLOR) {
sp_color_get_cmyk_floatv (&object->style->fill.value.color, d);
c[0] += d[0];
c[1] += d[1];
c[2] += d[2];
c[3] += d[3];
c[4] += SP_SCALE24_TO_FLOAT (object->style->fill_opacity.value);
}
num += 1;
objects = objects->next;
}
c[0] /= num;
c[1] /= num;
c[2] /= num;
c[3] /= num;
c[4] /= num;
}
void sp_document_set_height (SPDocument * document, gdouble height, const SPUnit *unit)
{
SPRoot *root = SP_ROOT(document->root);
if (root->height.unit == SVGLength::PERCENT && root->viewBox_set) { // set to viewBox=
root->viewBox.y1 = root->viewBox.y0 + sp_units_get_pixels (height, *unit);
} else { // set to height=
gdouble old_computed = root->height.computed;
root->height.computed = sp_units_get_pixels (height, *unit);
/* SVG does not support meters as a unit, so we must translate meters to
* cm when writing */
if (!strcmp(unit->abbr, "m")) {
root->height.value = 100*height;
root->height.unit = SVGLength::CM;
} else {
root->height.value = height;
root->height.unit = (SVGLength::Unit) sp_unit_get_svg_unit(unit);
}
if (root->viewBox_set)
root->viewBox.y1 = root->viewBox.y0 + (root->height.computed / old_computed) * (root->viewBox.y1 - root->viewBox.y0);
}
SP_OBJECT (root)->updateRepr();
}
/**
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.
*/
SPItem*
find_group_at_point(unsigned int dkey, SPGroup *group, Geom::Point const p)
{
SPItem *seen = NULL;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
gdouble delta = prefs->getDouble("/options/cursortolerance/value", 1.0);
for (SPObject *o = sp_object_first_child(SP_OBJECT(group)) ; o != NULL ; o = SP_OBJECT_NEXT(o) ) {
if (!SP_IS_ITEM(o)) continue;
if (SP_IS_GROUP(o) && SP_GROUP(o)->effectiveLayerMode(dkey) == SPGroup::LAYER) {
SPItem *newseen = find_group_at_point(dkey, SP_GROUP(o), p);
if (newseen) {
seen = newseen;
}
}
if (SP_IS_GROUP(o) && SP_GROUP(o)->effectiveLayerMode(dkey) != SPGroup::LAYER ) {
SPItem *child = SP_ITEM(o);
NRArenaItem *arenaitem = sp_item_get_arenaitem(child, dkey);
// seen remembers the last (topmost) of groups pickable at this point
if (arenaitem && nr_arena_item_invoke_pick(arenaitem, p, delta, 1) != NULL) {
seen = child;
}
}
}
return seen;
}
static void
sp_flowregionexclude_modified (SPObject *object, guint flags)
{
SPFlowregionExclude *group;
SPObject *child;
GSList *l;
group = SP_FLOWREGIONEXCLUDE (object);
if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
flags &= SP_OBJECT_MODIFIED_CASCADE;
l = NULL;
for (child = sp_object_first_child(object) ; child != NULL ; child = SP_OBJECT_NEXT(child) ) {
g_object_ref (G_OBJECT (child));
l = g_slist_prepend (l, child);
}
l = g_slist_reverse (l);
while (l) {
child = SP_OBJECT (l->data);
l = g_slist_remove (l, child);
if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
child->emitModified(flags);
}
g_object_unref (G_OBJECT (child));
}
}
NRArenaItem *
sp_clippath_show(SPClipPath *cp, NRArena *arena, unsigned int key)
{
g_return_val_if_fail(cp != NULL, NULL);
g_return_val_if_fail(SP_IS_CLIPPATH(cp), NULL);
g_return_val_if_fail(arena != NULL, NULL);
g_return_val_if_fail(NR_IS_ARENA(arena), NULL);
NRArenaItem *ai = NRArenaGroup::create(arena);
cp->display = sp_clippath_view_new_prepend(cp->display, key, ai);
for (SPObject *child = sp_object_first_child(SP_OBJECT(cp)) ; child != NULL; child = SP_OBJECT_NEXT(child)) {
if (SP_IS_ITEM(child)) {
NRArenaItem *ac = sp_item_invoke_show(SP_ITEM(child), arena, key, SP_ITEM_REFERENCE_FLAGS);
if (ac) {
/* The order is not important in clippath */
nr_arena_item_add_child(ai, ac, NULL);
}
}
}
if (cp->clipPathUnits == SP_CONTENT_UNITS_OBJECTBOUNDINGBOX) {
Geom::Matrix t(Geom::Scale(cp->display->bbox.x1 - cp->display->bbox.x0, cp->display->bbox.y1 - cp->display->bbox.y0));
t[4] = cp->display->bbox.x0;
t[5] = cp->display->bbox.y0;
nr_arena_group_set_child_transform(NR_ARENA_GROUP(ai), &t);
}
return ai;
}
static void
sp_flowpara_update (SPObject *object, SPCtx *ctx, unsigned int flags)
{
SPItemCtx *ictx=(SPItemCtx *) ctx;
SPItemCtx cctx=*ictx;
if (((SPObjectClass *) (flowpara_parent_class))->update)
((SPObjectClass *) (flowpara_parent_class))->update (object, ctx, flags);
if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
flags &= SP_OBJECT_MODIFIED_CASCADE;
GSList* l = NULL;
for (SPObject *child = sp_object_first_child(object) ; child != NULL ; child = SP_OBJECT_NEXT(child) ) {
g_object_ref (G_OBJECT (child));
l = g_slist_prepend (l, child);
}
l = g_slist_reverse (l);
while (l) {
SPObject *child = SP_OBJECT (l->data);
l = g_slist_remove (l, child);
if (flags || (child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
if (SP_IS_ITEM (child)) {
SPItem const &chi = *SP_ITEM(child);
cctx.i2doc = chi.transform * ictx->i2doc;
cctx.i2vp = chi.transform * ictx->i2vp;
child->updateDisplay((SPCtx *)&cctx, flags);
} else {
child->updateDisplay(ctx, flags);
}
}
g_object_unref (G_OBJECT (child));
}
}
void
PatternKnotHolderEntityScale::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
{
SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
// FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
Geom::Point p_snapped = snap_knot_position(p, state);
// get angle from current transform
gdouble theta = sp_pattern_extract_theta(pat);
// Get the new scale from the position of the knotholder
Geom::Point d = p_snapped - sp_pattern_extract_trans(pat);
gdouble pat_x = pattern_width(pat);
gdouble pat_y = pattern_height(pat);
Geom::Scale scl(1);
if ( state & GDK_CONTROL_MASK ) {
// if ctrl is pressed: use 1:1 scaling
gdouble pat_h = hypot(pat_x, pat_y);
scl = Geom::Scale(d.length() / pat_h);
} else {
d *= Geom::Rotate(-theta);
scl = Geom::Scale(d[Geom::X] / pat_x, d[Geom::Y] / pat_y);
}
Geom::Affine rot = (Geom::Affine)scl * Geom::Rotate(theta);
Geom::Point const t = sp_pattern_extract_trans(pat);
rot[4] = t[Geom::X];
rot[5] = t[Geom::Y];
item->adjust_pattern(rot, true);
item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
void
SPConnEndPair::setAttr(unsigned const key, gchar const *const value)
{
if (key == SP_ATTR_CONNECTOR_TYPE) {
if (value && (strcmp(value, "polyline") == 0)) {
_connType = SP_CONNECTOR_POLYLINE;
Avoid::Router *router = _path->document->router;
GQuark itemID = g_quark_from_string(SP_OBJECT(_path)->id);
_connRef = new Avoid::ConnRef(router, itemID);
_invalid_path_connection = connectInvalidPath(
sigc::ptr_fun(&sp_conn_adjust_invalid_path));
_transformed_connection = _path->connectTransformed(
sigc::ptr_fun(&avoid_conn_move));
}
else {
_connType = SP_CONNECTOR_NOAVOID;
if (_connRef) {
_connRef->removeFromGraph();
delete _connRef;
_connRef = NULL;
_invalid_path_connection.disconnect();
_transformed_connection.disconnect();
}
}
return;
}
unsigned const handle_ix = key - SP_ATTR_CONNECTION_START;
g_assert( handle_ix <= 1 );
this->_connEnd[handle_ix]->setAttacherHref(value);
}
static void
sp_flowpara_modified (SPObject *object, guint flags)
{
SPObject *child;
GSList *l;
if (((SPObjectClass *) (flowpara_parent_class))->modified)
((SPObjectClass *) (flowpara_parent_class))->modified (object, flags);
if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
flags &= SP_OBJECT_MODIFIED_CASCADE;
l = NULL;
for (child = sp_object_first_child(object) ; child != NULL ; child = SP_OBJECT_NEXT(child) ) {
g_object_ref (G_OBJECT (child));
l = g_slist_prepend (l, child);
}
l = g_slist_reverse (l);
while (l) {
child = SP_OBJECT (l->data);
l = g_slist_remove (l, child);
if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
child->emitModified(flags);
}
g_object_unref (G_OBJECT (child));
}
}
void
PatternKnotHolderEntityAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
// get the angle from pattern 0,0 to the cursor pos
Geom::Point delta = p - sp_pattern_extract_trans(pat);
gdouble theta = atan2(delta);
if ( state & GDK_CONTROL_MASK ) {
theta = sp_round(theta, M_PI/snaps);
}
// get the scale from the current transform so we can keep it.
Geom::Point scl = sp_pattern_extract_scale(pat);
Geom::Affine rot = Geom::Affine(Geom::Scale(scl)) * Geom::Affine(Geom::Rotate(theta));
Geom::Point const t = sp_pattern_extract_trans(pat);
rot[4] = t[Geom::X];
rot[5] = t[Geom::Y];
item->adjust_pattern(rot, true);
item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
void
sp_guide_remove (SPGuide * guide)
{
g_assert (SP_IS_GUIDE (guide));
sp_repr_unparent (SP_OBJECT (guide)->repr);
}
/**
Returns the bottommost item from the list which is at the point, or NULL if none.
*/
SPItem*
sp_document_item_from_list_at_point_bottom(unsigned int dkey, SPGroup *group, GSList const *list,
Geom::Point const p, bool take_insensitive)
{
g_return_val_if_fail(group, NULL);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
gdouble delta = prefs->getDouble("/options/cursortolerance/value", 1.0);
for (SPObject *o = sp_object_first_child(SP_OBJECT(group)) ; o != NULL ; o = SP_OBJECT_NEXT(o) ) {
if (!SP_IS_ITEM(o)) continue;
SPItem *item = SP_ITEM(o);
NRArenaItem *arenaitem = sp_item_get_arenaitem(item, dkey);
if (arenaitem && nr_arena_item_invoke_pick(arenaitem, p, delta, 1) != NULL
&& (take_insensitive || item->isVisibleAndUnlocked(dkey))) {
if (g_slist_find((GSList *) list, item) != NULL)
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;
}
void SPClipPath::modified(unsigned int flags) {
if (flags & SP_OBJECT_MODIFIED_FLAG) {
flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
}
flags &= SP_OBJECT_MODIFIED_CASCADE;
GSList *l = NULL;
for (SPObject *child = this->firstChild(); child; child = child->getNext()) {
sp_object_ref(child);
l = g_slist_prepend(l, child);
}
l = g_slist_reverse(l);
while (l) {
SPObject *child = SP_OBJECT(l->data);
l = g_slist_remove(l, child);
if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
child->emitModified(flags);
}
sp_object_unref(child);
}
}
static void
sp_mask_modified (SPObject *object, guint flags)
{
SPObjectGroup *og;
SPMask *cp;
SPObject *child;
GSList *l;
og = SP_OBJECTGROUP (object);
cp = SP_MASK (object);
if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
flags &= SP_OBJECT_MODIFIED_CASCADE;
l = NULL;
for (child = og->children; child != NULL; child = child->next) {
g_object_ref (G_OBJECT (child));
l = g_slist_prepend (l, child);
}
l = g_slist_reverse (l);
while (l) {
child = SP_OBJECT (l->data);
l = g_slist_remove (l, child);
if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
sp_object_invoke_modified (child, flags);
}
g_object_unref (G_OBJECT (child));
}
}
static void sp_tspan_bbox(SPItem const *item, NRRect *bbox, Geom::Matrix const &transform, unsigned const /*flags*/)
{
// find out the ancestor text which holds our layout
SPObject *parent_text = SP_OBJECT(item);
for (; parent_text != NULL && !SP_IS_TEXT(parent_text); parent_text = SP_OBJECT_PARENT (parent_text)){};
if (parent_text == NULL) return;
// get the bbox of our portion of the layout
SP_TEXT(parent_text)->layout.getBoundingBox(bbox, transform, sp_text_get_length_upto(parent_text, item), sp_text_get_length_upto(item, NULL) - 1);
// Add stroke width
SPStyle* style=SP_OBJECT_STYLE (item);
if (!style->stroke.isNone()) {
double const scale = transform.descrim();
if ( fabs(style->stroke_width.computed * scale) > 0.01 ) { // sinon c'est 0=oon veut pas de bord
double const width = MAX(0.125, style->stroke_width.computed * scale);
if ( fabs(bbox->x1 - bbox->x0) > -0.00001 && fabs(bbox->y1 - bbox->y0) > -0.00001 ) {
bbox->x0-=0.5*width;
bbox->x1+=0.5*width;
bbox->y0-=0.5*width;
bbox->y1+=0.5*width;
}
}
}
}
void
sp_sel_trans_shutdown (SPSelTrans *seltrans)
{
gint i;
for (i = 0; i < 8; i++) {
if (seltrans->shandle[i]) {
g_object_unref (G_OBJECT (seltrans->shandle[i]));
seltrans->shandle[i] = NULL;
}
if (seltrans->rhandle[i]) {
g_object_unref (G_OBJECT (seltrans->rhandle[i]));
seltrans->rhandle[i] = NULL;
}
}
if (seltrans->chandle) {
g_object_unref (G_OBJECT (seltrans->chandle));
seltrans->chandle = NULL;
}
if (seltrans->norm) {
gtk_object_destroy (GTK_OBJECT (seltrans->norm));
seltrans->norm = NULL;
}
if (seltrans->grip) {
gtk_object_destroy (GTK_OBJECT (seltrans->grip));
seltrans->grip = NULL;
}
if (seltrans->l1) {
gtk_object_destroy (GTK_OBJECT (seltrans->l1));
seltrans->l1 = NULL;
}
if (seltrans->l2) {
gtk_object_destroy (GTK_OBJECT (seltrans->l2));
seltrans->l2 = NULL;
}
if (seltrans->l3) {
gtk_object_destroy (GTK_OBJECT (seltrans->l3));
seltrans->l3 = NULL;
}
if (seltrans->l4) {
gtk_object_destroy (GTK_OBJECT (seltrans->l4));
seltrans->l4 = NULL;
}
if (seltrans->selection) {
sp_signal_disconnect_by_data (seltrans->selection, seltrans);
}
nr_free (seltrans->spp);
if (seltrans->items) {
int i;
for (i = 0; i < seltrans->nitems; i++) sp_object_unref (SP_OBJECT (seltrans->items[i]), NULL);
nr_free (seltrans->items);
}
if (seltrans->transforms) nr_free (seltrans->transforms);
}
/* We assert that realpixbuf is either NULL or identical size to pixbuf */
static void
sp_image_update_arenaitem (SPImage *image, Inkscape::DrawingImage *ai)
{
ai->setStyle(SP_OBJECT(image)->style);
ai->setPixbuf(image->pixbuf);
ai->setOrigin(Geom::Point(image->ox, image->oy));
ai->setScale(image->sx, image->sy);
ai->setClipbox(image->clipbox);
}
void
sp_sel_trans_grab (SPSelTrans * seltrans, NRPointF *p, gdouble x, gdouble y, gboolean show_handles)
{
SPSelection *selection;
const GSList *l;
int n;
selection = SP_DT_SELECTION (seltrans->desktop);
g_return_if_fail (!seltrans->grabbed);
seltrans->grabbed = TRUE;
seltrans->show_handles = show_handles;
sp_sel_trans_update_volatile_state (seltrans);
seltrans->changed = FALSE;
if (seltrans->empty) return;
l = sp_selection_item_list (selection);
seltrans->nitems = g_slist_length ((GSList *) l);
seltrans->items = nr_new (SPItem *, seltrans->nitems);
seltrans->transforms = nr_new (NRMatrixF, seltrans->nitems);
n = 0;
while (l) {
seltrans->items[n] = (SPItem *) sp_object_ref (SP_OBJECT (l->data), NULL);
sp_item_i2d_affine (seltrans->items[n], &seltrans->transforms[n]);
l = l->next;
n += 1;
}
nr_matrix_d_set_identity (&seltrans->current);
seltrans->point.x = p->x;
seltrans->point.y = p->y;
seltrans->spp_length = sp_selection_snappoints (selection, seltrans->spp, SP_SELTRANS_SPP_SIZE);
seltrans->opposit.x = seltrans->box.x0 + (1 - x) * fabs (seltrans->box.x1 - seltrans->box.x0);
seltrans->opposit.y = seltrans->box.y0 + (1 - y) * fabs (seltrans->box.y1 - seltrans->box.y0);
if ((x != -1) && (y != -1)) {
sp_canvas_item_show (seltrans->norm);
sp_canvas_item_show (seltrans->grip);
}
if (seltrans->show == SP_SELTRANS_SHOW_OUTLINE) {
sp_canvas_item_show (seltrans->l1);
sp_canvas_item_show (seltrans->l2);
sp_canvas_item_show (seltrans->l3);
sp_canvas_item_show (seltrans->l4);
}
sp_sel_trans_update_handles (seltrans);
g_return_if_fail(seltrans->stamp_cache == NULL);
}
void
sp_guide_position_set (SPGuide * guide, gdouble x, gdouble y)
{
g_assert (SP_IS_GUIDE (guide));
sp_guide_moveto (guide, x, y);
sp_repr_set_double_attribute (SP_OBJECT (guide)->repr,
"position", (guide->orientation == SP_GUIDE_HORIZONTAL) ? y : x);
}
static bool
sp_select_context_abort(SPEventContext *event_context)
{
SPDesktop *desktop = event_context->desktop;
SPSelectContext *sc = SP_SELECT_CONTEXT(event_context);
Inkscape::SelTrans *seltrans = sc->_seltrans;
if (sc->dragging) {
if (sc->moved) { // cancel dragging an object
seltrans->ungrab();
sc->moved = FALSE;
sc->dragging = FALSE;
sp_event_context_discard_delayed_snap_event(event_context);
drag_escaped = 1;
if (sc->item) {
// only undo if the item is still valid
if (SP_OBJECT_DOCUMENT( SP_OBJECT(sc->item))) {
sp_document_undo(sp_desktop_document(desktop));
}
sp_object_unref( SP_OBJECT(sc->item), NULL);
} else if (sc->button_press_ctrl) {
// NOTE: This is a workaround to a bug.
// When the ctrl key is held, sc->item is not defined
// so in this case (only), we skip the object doc check
sp_document_undo(sp_desktop_document(desktop));
}
sc->item = NULL;
SP_EVENT_CONTEXT(sc)->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Move canceled."));
return true;
}
} else {
if (Inkscape::Rubberband::get(desktop)->is_started()) {
Inkscape::Rubberband::get(desktop)->stop();
rb_escaped = 1;
SP_EVENT_CONTEXT(sc)->defaultMessageContext()->clear();
SP_EVENT_CONTEXT(sc)->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Selection canceled."));
return true;
}
}
return false;
}
GSList *
all_selection_items (Inkscape::Selection *s, GSList *l, SPObject *ancestor, bool hidden, bool locked)
{
SPDesktop *desktop = SP_ACTIVE_DESKTOP;
for (GSList *i = (GSList *) s->itemList(); i != NULL; i = i->next) {
if (SP_IS_ITEM (i->data) && !SP_OBJECT_IS_CLONED (i->data) && !desktop->isLayer(SP_ITEM(i->data))) {
if (!ancestor || ancestor->isAncestorOf(SP_OBJECT (i->data))) {
if ((hidden || !desktop->itemIsHidden(SP_ITEM(i->data))) && (locked || !SP_ITEM(i->data)->isLocked())) {
l = g_slist_prepend (l, i->data);
}
}
}
if (!ancestor || ancestor->isAncestorOf(SP_OBJECT (i->data))) {
l = all_items (SP_OBJECT (i->data), l, hidden, locked);
}
}
return l;
}
void SPDocument::add_persp3d (Persp3D * const /*persp*/)
{
SPDefs *defs = SP_ROOT(this->root)->defs;
for (SPObject *i = sp_object_first_child(SP_OBJECT(defs)); i != NULL; i = SP_OBJECT_NEXT(i) ) {
if (SP_IS_PERSP3D(i)) {
g_print ("Encountered a Persp3D in defs\n");
}
}
g_print ("Adding Persp3D to defs\n");
persp3d_create_xml_element (this);
}
void
sp_sel_trans_stamp (SPSelTrans * seltrans)
{
/* stamping mode */
SPItem * original_item, * copy_item;
SPRepr * original_repr, * copy_repr;
GSList * l;
gchar tstr[80];
NRMatrixF i2d, i2dnew;
NRMatrixF *new_affine;
tstr[79] = '\0';
if (!seltrans->empty) {
if (seltrans->stamp_cache) {
l = seltrans->stamp_cache;
} else {
/* Build cache */
l = (GSList *) sp_selection_item_list (SP_DT_SELECTION (seltrans->desktop));
l = g_slist_copy (l);
l = g_slist_sort (l, (GCompareFunc) sp_object_compare_position);
seltrans->stamp_cache = l;
}
while (l) {
original_item = SP_ITEM(l->data);
original_repr = (SPRepr *)(SP_OBJECT (original_item)->repr);
copy_repr = sp_repr_duplicate (original_repr);
copy_item = (SPItem *) sp_document_add_repr (SP_DT_DOCUMENT (seltrans->desktop),
copy_repr);
if (seltrans->show == SP_SELTRANS_SHOW_OUTLINE) {
sp_item_i2d_affine (original_item, &i2d);
nr_matrix_multiply_ffd (&i2dnew, &i2d, &seltrans->current);
sp_item_set_i2d_affine (copy_item, &i2dnew);
new_affine = ©_item->transform;
} else {
new_affine = &original_item->transform;
}
if (sp_svg_transform_write (tstr, 80, new_affine)) {
sp_repr_set_attr (copy_repr, "transform", tstr);
} else {
sp_repr_set_attr (copy_repr, "transform", NULL);
}
sp_repr_unref (copy_repr);
l = l->next;
}
sp_document_done (SP_DT_DOCUMENT (seltrans->desktop));
}
}
void
sp_conn_end_href_changed(SPObject */*old_ref*/, SPObject */*ref*/,
SPConnEnd *connEndPtr, SPPath *const path, unsigned const handle_ix)
{
g_return_if_fail(connEndPtr != NULL);
SPConnEnd &connEnd = *connEndPtr;
connEnd._delete_connection.disconnect();
connEnd._transformed_connection.disconnect();
if (connEnd.href) {
SPObject *refobj = connEnd.ref.getObject();
if (refobj) {
connEnd._delete_connection
= SP_OBJECT(refobj)->connectDelete(sigc::bind(sigc::ptr_fun(&sp_conn_end_deleted),
SP_OBJECT(path), handle_ix));
connEnd._transformed_connection
= SP_ITEM(refobj)->connectTransformed(sigc::bind(sigc::ptr_fun(&sp_conn_end_shape_move),
path));
}
}
}
/**
Returns true if an item is among the descendants of group (recursively).
*/
bool item_is_in_group(SPItem *item, SPGroup *group)
{
for (SPObject *o = sp_object_first_child(SP_OBJECT(group)) ; o != NULL ; o = SP_OBJECT_NEXT(o) ) {
if (!SP_IS_ITEM(o)) continue;
if (SP_ITEM(o) == item)
return true;
if (SP_IS_GROUP(o))
if (item_is_in_group(item, SP_GROUP(o)))
return true;
}
return false;
}
