/*
* TODO: Is it guaranteed that the returned extension is valid? If so, we can remove the check for
* filename_extension in sp_file_save_dialog().
*/
Glib::ustring
get_file_save_extension (Inkscape::Extension::FileSaveMethod method) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Glib::ustring extension;
switch (method) {
case FILE_SAVE_METHOD_SAVE_AS:
case FILE_SAVE_METHOD_TEMPORARY:
extension = prefs->getString("/dialogs/save_as/default");
break;
case FILE_SAVE_METHOD_SAVE_COPY:
extension = prefs->getString("/dialogs/save_copy/default");
break;
case FILE_SAVE_METHOD_INKSCAPE_SVG:
extension = SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE;
break;
case FILE_SAVE_METHOD_EXPORT:
/// \todo no default extension set for Export? defaults to SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE is ok?
break;
}
if(extension.empty()) {
extension = SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE;
}
return extension;
}
void
lpetool_update_measuring_items(LpeTool *lc)
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
for ( std::map<SPPath *, SPCanvasItem*>::iterator i = lc->measuring_items->begin();
i != lc->measuring_items->end();
++i )
{
SPPath *path = i->first;
SPCurve *curve = path->getCurve();
Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2 = Geom::paths_to_pw(curve->get_pathvector());
Inkscape::Util::Unit const * unit = NULL;
if (prefs->getString("/tools/lpetool/unit").compare("")) {
unit = unit_table.getUnit(prefs->getString("/tools/lpetool/unit"));
} else {
unit = unit_table.getUnit("px");
}
double lengthval = Geom::length(pwd2);
lengthval = Inkscape::Util::Quantity::convert(lengthval, "px", unit);
gchar *arc_length = g_strdup_printf("%.2f %s", lengthval, unit->abbr.c_str());
sp_canvastext_set_text (SP_CANVASTEXT(i->second), arc_length);
set_pos_and_anchor(SP_CANVASTEXT(i->second), pwd2, 0.5, 10);
// TODO: must we free arc_length?
}
}
Glib::ustring
get_file_save_path (SPDocument *doc, FileSaveMethod method) {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Glib::ustring path;
bool use_current_dir = true;
switch (method) {
case FILE_SAVE_METHOD_SAVE_AS:
{
use_current_dir = prefs->getBool("/dialogs/save_as/use_current_dir", true);
if (doc->getURI() && use_current_dir) {
path = Glib::path_get_dirname(doc->getURI());
} else {
path = prefs->getString("/dialogs/save_as/path");
}
break;
}
case FILE_SAVE_METHOD_TEMPORARY:
path = prefs->getString("/dialogs/save_as/path");
break;
case FILE_SAVE_METHOD_SAVE_COPY:
use_current_dir = prefs->getBool("/dialogs/save_copy/use_current_dir", prefs->getBool("/dialogs/save_as/use_current_dir", true));
if (doc->getURI() && use_current_dir) {
path = Glib::path_get_dirname(doc->getURI());
} else {
path = prefs->getString("/dialogs/save_copy/path");
}
break;
case FILE_SAVE_METHOD_INKSCAPE_SVG:
if (doc->getURI()) {
path = Glib::path_get_dirname(doc->getURI());
} else {
// FIXME: should we use the save_as path here or something else? Maybe we should
// leave this as a choice to the user.
path = prefs->getString("/dialogs/save_as/path");
}
break;
case FILE_SAVE_METHOD_EXPORT:
/// \todo no default path set for Export?
// defaults to g_get_home_dir()
break;
}
if(path.empty()) {
path = g_get_home_dir(); // Is this the most sensible solution? Note that we should avoid
// g_get_current_dir because this leads to problems on OS X where
// Inkscape opens the dialog inside application bundle when it is
// invoked for the first teim.
}
return path;
}
void
lpetool_create_measuring_items(LpeTool *lc, Inkscape::Selection *selection)
{
if (!selection) {
selection = lc->desktop->getSelection();
}
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool show = prefs->getBool("/tools/lpetool/show_measuring_info", true);
SPPath *path;
SPCurve *curve;
SPCanvasText *canvas_text;
SPCanvasGroup *tmpgrp = lc->desktop->getTempGroup();
gchar *arc_length;
double lengthval;
std::vector<SPItem*> items=selection->itemList();
for(std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();++i){
if (SP_IS_PATH(*i)) {
path = SP_PATH(*i);
curve = path->getCurve();
Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2 = paths_to_pw(curve->get_pathvector());
canvas_text = (SPCanvasText *) sp_canvastext_new(tmpgrp, lc->desktop, Geom::Point(0,0), "");
if (!show)
sp_canvas_item_hide(SP_CANVAS_ITEM(canvas_text));
Inkscape::Util::Unit const * unit = NULL;
if (prefs->getString("/tools/lpetool/unit").compare("")) {
unit = unit_table.getUnit(prefs->getString("/tools/lpetool/unit"));
} else {
unit = unit_table.getUnit("px");
}
lengthval = Geom::length(pwd2);
lengthval = Inkscape::Util::Quantity::convert(lengthval, "px", unit);
arc_length = g_strdup_printf("%.2f %s", lengthval, unit->abbr.c_str());
sp_canvastext_set_text (canvas_text, arc_length);
set_pos_and_anchor(canvas_text, pwd2, 0.5, 10);
// TODO: must we free arc_length?
(*lc->measuring_items)[path] = SP_CANVAS_ITEM(canvas_text);
}
}
}
static gchar* getImageEditorName() {
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
gchar* value = 0;
Glib::ustring choices = prefs->getString("/options/bitmapeditor/choices");
if (!choices.empty()) {
gchar** splits = g_strsplit(choices.data(), ",", 0);
gint numIems = g_strv_length(splits);
int setting = prefs->getIntLimited("/options/bitmapeditor/value", 0, 0, numIems);
value = g_strdup(splits[setting]);
g_strfreev(splits);
}
if (!value) {
value = g_strdup("gimp");
}
return value;
}
void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObject* holder)
{
UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
tracker->setActiveUnitByAbbr(prefs->getString("/tools/measure/unit").c_str());
g_object_set_data( holder, "tracker", tracker );
EgeAdjustmentAction *eact = 0;
/* Font Size */
{
eact = create_adjustment_action( "MeasureFontSizeAction",
_("Font Size"), _("Font Size:"),
_("The font size to be used in the measurement labels"),
"/tools/measure/fontsize", 0.0,
GTK_WIDGET(desktop->canvas), holder, FALSE, NULL,
10, 36, 1.0, 4.0,
0, 0, 0,
sp_measure_fontsize_value_changed);
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
}
// units label
{
EgeOutputAction* act = ege_output_action_new( "measure_units_label", _("Units:"), _("The units to be used for the measurements"), 0 );
ege_output_action_set_use_markup( act, TRUE );
g_object_set( act, "visible-overflown", FALSE, NULL );
gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
}
// units menu
{
GtkAction* act = tracker->createAction( "MeasureUnitsAction", _("Units:"), _("The units to be used for the measurements") );
g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(measure_unit_changed), holder );
gtk_action_group_add_action( mainActions, act );
}
} // end of sp_measure_toolbox_prep()
void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
{
EgeAdjustmentAction* eact = 0;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
{
GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
GList* items = 0;
gint count = 0;
for ( items = Inkscape::UI::Tools::flood_channels_dropdown_items_list(); items ; items = g_list_next(items) )
{
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
count++;
}
g_list_free( items );
items = 0;
EgeSelectOneAction* act1 = ege_select_one_action_new( "ChannelsAction", _("Fill by"), (""), NULL, GTK_TREE_MODEL(model) );
g_object_set( act1, "short_label", _("Fill by:"), NULL );
ege_select_one_action_set_appearance( act1, "compact" );
ege_select_one_action_set_active( act1, prefs->getInt("/tools/paintbucket/channels", 0) );
g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(paintbucket_channels_changed), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(act1) );
g_object_set_data( holder, "channels_action", act1 );
}
// Spacing spinbox
{
eact = create_adjustment_action(
"ThresholdAction",
_("Fill Threshold"), _("Threshold:"),
_("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"),
"/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas), holder, TRUE,
"inkscape:paintbucket-threshold", 0, 100.0, 1.0, 10.0,
0, 0, 0,
paintbucket_threshold_changed, NULL /*unit tracker*/, 1, 0 );
ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
}
// Create the units menu.
UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR);
Glib::ustring stored_unit = prefs->getString("/tools/paintbucket/offsetunits");
if (!stored_unit.empty()) {
Unit const *u = unit_table.getUnit(stored_unit);
tracker->setActiveUnit(u);
}
g_object_set_data( holder, "tracker", tracker );
{
GtkAction* act = tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") );
gtk_action_group_add_action( mainActions, act );
}
// Offset spinbox
{
eact = create_adjustment_action(
"OffsetAction",
_("Grow/shrink by"), _("Grow/shrink by:"),
_("The amount to grow (positive) or shrink (negative) the created fill path"),
"/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas), holder, TRUE,
"inkscape:paintbucket-offset", -1e4, 1e4, 0.1, 0.5,
0, 0, 0,
paintbucket_offset_changed, tracker, 1, 2);
tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) );
gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
}
/* Auto Gap */
{
GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
GList* items = 0;
gint count = 0;
for ( items = Inkscape::UI::Tools::flood_autogap_dropdown_items_list(); items ; items = g_list_next(items) )
{
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, reinterpret_cast<gchar*>(items->data), 1, count, -1 );
count++;
}
g_list_free( items );
items = 0;
EgeSelectOneAction* act2 = ege_select_one_action_new( "AutoGapAction", _("Close gaps"), (""), NULL, GTK_TREE_MODEL(model) );
g_object_set( act2, "short_label", _("Close gaps:"), NULL );
ege_select_one_action_set_appearance( act2, "compact" );
ege_select_one_action_set_active( act2, prefs->getBool("/tools/paintbucket/autogap") );
g_signal_connect( G_OBJECT(act2), "changed", G_CALLBACK(paintbucket_autogap_changed), holder );
gtk_action_group_add_action( mainActions, GTK_ACTION(act2) );
g_object_set_data( holder, "autogap_action", act2 );
}
/* Reset */
{
GtkAction* act = gtk_action_new( "PaintbucketResetAction",
_("Defaults"),
_("Reset paint bucket parameters to defaults (use Inkscape Preferences > Tools to change defaults)"),
GTK_STOCK_CLEAR );
g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(paintbucket_defaults), holder );
gtk_action_group_add_action( mainActions, act );
gtk_action_set_sensitive( act, TRUE );
}
}
SPDocument *
GdkpixbufInput::open(Inkscape::Extension::Input *mod, char const *uri)
{
// Determine whether the image should be embedded
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool ask = prefs->getBool("/dialogs/import/ask");
Glib::ustring link = prefs->getString("/dialogs/import/link");
bool forcexdpi = prefs->getBool("/dialogs/import/forcexdpi");
Glib::ustring scale = prefs->getString("/dialogs/import/scale");
// std::cout << "GkdpixbufInput::open: "
// << " ask: " << ask
// << ", link: " << link
// << ", forcexdpi: " << forcexdpi
// << ", scale: " << scale << std::endl;
// std::cout << " in preferences: "
// << " ask: " << !mod->get_param_bool("do_not_ask")
// << ", link: " << mod->get_param_optiongroup("link")
// << ", mod_dpi: " << mod->get_param_optiongroup("dpi")
// << ", scale: " << mod->get_param_optiongroup("scale") << std::endl;
if( ask ) {
Glib::ustring mod_link = mod->get_param_optiongroup("link");
Glib::ustring mod_dpi = mod->get_param_optiongroup("dpi");
bool mod_forcexdpi = ( mod_dpi.compare( "from_default" ) == 0 );
Glib::ustring mod_scale = mod->get_param_optiongroup("scale");
if( link.compare( mod_link ) != 0 ) {
link = mod_link;
}
prefs->setString("/dialogs/import/link", link );
if( forcexdpi != mod_forcexdpi ) {
forcexdpi = mod_forcexdpi;
}
prefs->setBool("/dialogs/import/forcexdpi", forcexdpi );
if( scale.compare( mod_scale ) != 0 ) {
scale = mod_scale;
}
prefs->setString("/dialogs/import/scale", scale );
prefs->setBool("/dialogs/import/ask", !mod->get_param_bool("do_not_ask") );
}
bool embed = ( link.compare( "embed" ) == 0 );
SPDocument *doc = NULL;
boost::scoped_ptr<Inkscape::Pixbuf> pb(Inkscape::Pixbuf::create_from_file(uri));
// TODO: the pixbuf is created again from the base64-encoded attribute in SPImage.
// Find a way to create the pixbuf only once.
if (pb) {
doc = SPDocument::createNewDoc(NULL, TRUE, TRUE);
bool saved = DocumentUndo::getUndoSensitive(doc);
DocumentUndo::setUndoSensitive(doc, false); // no need to undo in this temporary document
double width = pb->width();
double height = pb->height();
double defaultxdpi = prefs->getDouble("/dialogs/import/defaultxdpi/value", Inkscape::Util::Quantity::convert(1, "in", "px"));
//bool forcexdpi = prefs->getBool("/dialogs/import/forcexdpi");
ImageResolution *ir = 0;
double xscale = 1;
double yscale = 1;
if (!ir && !forcexdpi) {
ir = new ImageResolution(uri);
}
if (ir && ir->ok()) {
xscale = 900.0 / floor(10.*ir->x() + .5); // round-off to 0.1 dpi
yscale = 900.0 / floor(10.*ir->y() + .5);
} else {
xscale = 90.0 / defaultxdpi;
yscale = 90.0 / defaultxdpi;
}
width *= xscale;
height *= yscale;
delete ir; // deleting NULL is safe
// Create image node
Inkscape::XML::Document *xml_doc = doc->getReprDoc();
Inkscape::XML::Node *image_node = xml_doc->createElement("svg:image");
sp_repr_set_svg_double(image_node, "width", width);
sp_repr_set_svg_double(image_node, "height", height);
// Added 11 Feb 2014 as we now honor "preserveAspectRatio" and this is
// what Inkscaper's expect.
image_node->setAttribute("preserveAspectRatio", "none");
if( scale.compare( "auto" ) != 0 ) {
SPCSSAttr *css = sp_repr_css_attr_new();
sp_repr_css_set_property(css, "image-rendering", scale.c_str());
sp_repr_css_set(image_node, css, "style");
sp_repr_css_attr_unref( css );
}
if (embed) {
sp_embed_image(image_node, pb.get());
} else {
// convert filename to uri
gchar* _uri = g_filename_to_uri(uri, NULL, NULL);
if(_uri) {
image_node->setAttribute("xlink:href", _uri);
g_free(_uri);
} else {
image_node->setAttribute("xlink:href", uri);
}
}
// Add it to the current layer
doc->getRoot()->appendChildRepr(image_node);
Inkscape::GC::release(image_node);
fit_canvas_to_drawing(doc);
// Set viewBox if it doesn't exist
if (!doc->getRoot()->viewBox_set) {
//std::cout << "Viewbox not set, setting" << std::endl;
doc->setViewBox(Geom::Rect::from_xywh(0, 0, doc->getWidth().value(doc->getDefaultUnit()), doc->getHeight().value(doc->getDefaultUnit())));
}
// restore undo, as now this document may be shown to the user if a bitmap was opened
DocumentUndo::setUndoSensitive(doc, saved);
} else {
printf("GdkPixbuf loader failed\n");
}
return doc;
}
SPDocument *
sp_document_create(Inkscape::XML::Document *rdoc,
gchar const *uri,
gchar const *base,
gchar const *name,
unsigned int keepalive)
{
SPDocument *document;
Inkscape::XML::Node *rroot;
Inkscape::Version sodipodi_version;
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
rroot = rdoc->root();
document = new SPDocument();
document->keepalive = keepalive;
document->rdoc = rdoc;
document->rroot = rroot;
#ifndef WIN32
prepend_current_dir_if_relative(&(document->uri), uri);
#else
// FIXME: it may be that prepend_current_dir_if_relative works OK on windows too, test!
document->uri = uri? g_strdup(uri) : NULL;
#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)
document->base = g_strdup(base);
else
document->base = NULL;
document->name = g_strdup(name);
document->root = sp_object_repr_build_tree(document, rroot);
sodipodi_version = SP_ROOT(document->root)->version.sodipodi;
/* fixme: Not sure about this, but lets assume ::build updates */
rroot->setAttribute("sodipodi:version", SODIPODI_VERSION);
rroot->setAttribute("inkscape:version", Inkscape::version_string);
/* fixme: Again, I moved these here to allow version determining in ::build (Lauris) */
/* Quick hack 2 - get default image size into document */
if (!rroot->attribute("width")) rroot->setAttribute("width", "100%");
if (!rroot->attribute("height")) rroot->setAttribute("height", "100%");
/* End of quick hack 2 */
/* Quick hack 3 - Set uri attributes */
if (uri) {
rroot->setAttribute("sodipodi:docname", uri);
}
/* End of quick hack 3 */
/* Eliminate obsolete sodipodi:docbase, for privacy reasons */
rroot->setAttribute("sodipodi:docbase", NULL);
/* Eliminate any claim to adhere to a profile, as we don't try to */
rroot->setAttribute("baseProfile", NULL);
// creating namedview
if (!sp_item_group_get_child_by_name((SPGroup *) document->root, NULL, "sodipodi:namedview")) {
// if there's none in the document already,
Inkscape::XML::Node *rnew = NULL;
rnew = rdoc->createElement("sodipodi:namedview");
//rnew->setAttribute("id", "base");
// Add namedview data from the preferences
// we can't use getAllEntries because this could produce non-SVG doubles
Glib::ustring pagecolor = prefs->getString("/template/base/pagecolor");
if (!pagecolor.empty()) {
rnew->setAttribute("pagecolor", pagecolor.data());
}
Glib::ustring bordercolor = prefs->getString("/template/base/bordercolor");
if (!bordercolor.empty()) {
rnew->setAttribute("bordercolor", bordercolor.data());
}
sp_repr_set_svg_double(rnew, "borderopacity",
prefs->getDouble("/template/base/borderopacity", 1.0));
sp_repr_set_svg_double(rnew, "objecttolerance",
prefs->getDouble("/template/base/objecttolerance", 10.0));
sp_repr_set_svg_double(rnew, "gridtolerance",
prefs->getDouble("/template/base/gridtolerance", 10.0));
sp_repr_set_svg_double(rnew, "guidetolerance",
prefs->getDouble("/template/base/guidetolerance", 10.0));
sp_repr_set_svg_double(rnew, "inkscape:pageopacity",
prefs->getDouble("/template/base/inkscape:pageopacity", 0.0));
sp_repr_set_int(rnew, "inkscape:pageshadow",
prefs->getInt("/template/base/inkscape:pageshadow", 2));
sp_repr_set_int(rnew, "inkscape:window-width",
prefs->getInt("/template/base/inkscape:window-width", 640));
sp_repr_set_int(rnew, "inkscape:window-height",
prefs->getInt("/template/base/inkscape:window-height", 480));
// insert into the document
rroot->addChild(rnew, NULL);
// clean up
Inkscape::GC::release(rnew);
}
/* Defs */
if (!SP_ROOT(document->root)->defs) {
Inkscape::XML::Node *r;
r = rdoc->createElement("svg:defs");
rroot->addChild(r, NULL);
Inkscape::GC::release(r);
g_assert(SP_ROOT(document->root)->defs);
}
/* Default RDF */
rdf_set_defaults( document );
if (keepalive) {
inkscape_ref();
}
// Remark: Here, we used to create a "currentpersp3d" element in the document defs.
// But this is probably a bad idea since we need to adapt it for every change of selection, which will
// completely clutter the undo history. Maybe rather save it to prefs on exit and re-read it on startup?
document->current_persp3d = persp3d_document_first_persp(document);
if (!document->current_persp3d) {
document->current_persp3d = persp3d_create_xml_element (document);
}
sp_document_set_undo_sensitive(document, true);
// reset undo key when selection changes, so that same-key actions on different objects are not coalesced
if (!Inkscape::NSApplication::Application::getNewGui()) {
g_signal_connect(G_OBJECT(INKSCAPE), "change_selection",
G_CALLBACK(sp_document_reset_key), document);
g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop",
G_CALLBACK(sp_document_reset_key), document);
} 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;
}
static void sp_box3d_drag(Box3DContext &bc, guint /*state*/)
{
SPDesktop *desktop = bc.desktop;
if (!bc.item) {
if (Inkscape::have_viable_layer(desktop, bc._message_context) == false) {
return;
}
// Create object
SPBox3D *box3d = 0;
box3d = SPBox3D::createBox3D((SPItem *)desktop->currentLayer());
// Set style
desktop->applyCurrentOrToolStyle(box3d, "/tools/shapes/3dbox", false);
bc.item = box3d;
// TODO: Incorporate this in box3d-side.cpp!
for (int i = 0; i < 6; ++i) {
Box3DSide *side = Box3DSide::createBox3DSide(box3d);
guint desc = Box3D::int_to_face(i);
Box3D::Axis plane = (Box3D::Axis) (desc & 0x7);
plane = (Box3D::is_plane(plane) ? plane : Box3D::orth_plane_or_axis(plane));
side->dir1 = Box3D::extract_first_axis_direction(plane);
side->dir2 = Box3D::extract_second_axis_direction(plane);
side->front_or_rear = (Box3D::FrontOrRear) (desc & 0x8);
// Set style
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Glib::ustring descr = "/desktop/";
descr += box3d_side_axes_string(side);
descr += "/style";
Glib::ustring cur_style = prefs->getString(descr);
bool use_current = prefs->getBool("/tools/shapes/3dbox/usecurrent", false);
if (use_current && !cur_style.empty()) {
// use last used style
side->setAttribute("style", cur_style.data());
} else {
// use default style
GString *pstring = g_string_new("");
g_string_printf (pstring, "/tools/shapes/3dbox/%s", box3d_side_axes_string(side));
desktop->applyCurrentOrToolStyle (side, pstring->str, false);
}
side->updateRepr(); // calls box3d_side_write() and updates, e.g., the axes string description
}
box3d_set_z_orders(SP_BOX3D(bc.item));
bc.item->updateRepr();
// TODO: It would be nice to show the VPs during dragging, but since there is no selection
// at this point (only after finishing the box), we must do this "manually"
/* bc._vpdrag->updateDraggers(); */
desktop->canvas->forceFullRedrawAfterInterruptions(5);
}
g_assert(bc.item);
SPBox3D *box = SP_BOX3D(bc.item);
box->orig_corner0 = bc.drag_origin_proj;
box->orig_corner7 = bc.drag_ptC_proj;
box3d_check_for_swapped_coords(box);
/* we need to call this from here (instead of from box3d_position_set(), for example)
because z-order setting must not interfere with display updates during undo/redo */
box3d_set_z_orders (box);
box3d_position_set(box);
// status text
bc._message_context->setF(Inkscape::NORMAL_MESSAGE, _("<b>3D Box</b>; with <b>Shift</b> to extrude along the Z axis"));
}
ParamRadioButton::ParamRadioButton (const gchar * name,
const gchar * guitext,
const gchar * desc,
const Parameter::_scope_t scope,
bool gui_hidden,
const gchar * gui_tip,
Inkscape::Extension::Extension * ext,
Inkscape::XML::Node * xml,
AppearanceMode mode) :
Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext),
_value(0),
_mode(mode),
choices(0)
{
// Read XML tree to add enumeration items:
// printf("Extension Constructor: ");
if (xml != NULL) {
Inkscape::XML::Node *child_repr = sp_repr_children(xml);
while (child_repr != NULL) {
char const * chname = child_repr->name();
if (!strcmp(chname, INKSCAPE_EXTENSION_NS "option") || !strcmp(chname, INKSCAPE_EXTENSION_NS "_option")) {
Glib::ustring * newguitext = NULL;
Glib::ustring * newvalue = NULL;
const char * contents = sp_repr_children(child_repr)->content();
if (contents != NULL)
// don't translate when 'option' but do translate when '_option'
newguitext = new Glib::ustring( !strcmp(chname, INKSCAPE_EXTENSION_NS "_option") ? _(contents) : contents );
else
continue;
const char * val = child_repr->attribute("value");
if (val != NULL)
newvalue = new Glib::ustring(val);
else
newvalue = new Glib::ustring(contents);
if ( (newguitext) && (newvalue) ) { // logical error if this is not true here
choices = g_slist_append( choices, new optionentry(newvalue, newguitext) );
}
}
child_repr = sp_repr_next(child_repr);
}
}
// Initialize _value with the default value from xml
// for simplicity : default to the contents of the first xml-child
const char * defaultval = NULL;
if (choices)
defaultval = ((optionentry*) choices->data)->value->c_str();
gchar * pref_name = this->pref_name();
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Glib::ustring paramval = prefs->getString(extension_pref_root + pref_name);
g_free(pref_name);
if (!paramval.empty())
defaultval = paramval.data();
if (defaultval != NULL)
_value = g_strdup(defaultval); // allocate space for _value
return;
}
cmsHTRANSFORM Inkscape::CMSSystem::getDisplayTransform()
{
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
bool fromDisplay = prefs->getBool( "/options/displayprofile/from_display");
if ( fromDisplay ) {
if ( transf ) {
cmsDeleteTransform(transf);
transf = 0;
}
return 0;
}
bool warn = prefs->getBool( "/options/softproof/gamutwarn");
int intent = prefs->getIntLimited( "/options/displayprofile/intent", 0, 0, 3 );
int proofIntent = prefs->getIntLimited( "/options/softproof/intent", 0, 0, 3 );
bool bpc = prefs->getBool( "/options/softproof/bpc");
#if defined(cmsFLAGS_PRESERVEBLACK)
bool preserveBlack = prefs->getBool( "/options/softproof/preserveblack");
#endif //defined(cmsFLAGS_PRESERVEBLACK)
Glib::ustring colorStr = prefs->getString("/options/softproof/gamutcolor");
#if WITH_GTKMM_3_0
Gdk::RGBA gamutColor( colorStr.empty() ? "#808080" : colorStr );
#else
Gdk::Color gamutColor( colorStr.empty() ? "#808080" : colorStr );
#endif
if ( (warn != gamutWarn)
|| (lastIntent != intent)
|| (lastProofIntent != proofIntent)
|| (bpc != lastBPC)
#if defined(cmsFLAGS_PRESERVEBLACK)
|| (preserveBlack != lastPreserveBlack)
#endif // defined(cmsFLAGS_PRESERVEBLACK)
|| (gamutColor != lastGamutColor)
) {
gamutWarn = warn;
free_transforms();
lastIntent = intent;
lastProofIntent = proofIntent;
lastBPC = bpc;
#if defined(cmsFLAGS_PRESERVEBLACK)
lastPreserveBlack = preserveBlack;
#endif // defined(cmsFLAGS_PRESERVEBLACK)
lastGamutColor = gamutColor;
}
// Fetch these now, as they might clear the transform as a side effect.
cmsHPROFILE hprof = getSystemProfileHandle();
cmsHPROFILE proofProf = hprof ? getProofProfileHandle() : 0;
if ( !transf ) {
if ( hprof && proofProf ) {
cmsUInt32Number dwFlags = cmsFLAGS_SOFTPROOFING;
if ( gamutWarn ) {
dwFlags |= cmsFLAGS_GAMUTCHECK;
#if WITH_GTKMM_3_0
gushort gamutColor_r = gamutColor.get_red_u();
gushort gamutColor_g = gamutColor.get_green_u();
gushort gamutColor_b = gamutColor.get_blue_u();
#else
gushort gamutColor_r = gamutColor.get_red();
gushort gamutColor_g = gamutColor.get_green();
gushort gamutColor_b = gamutColor.get_blue();
#endif
#if HAVE_LIBLCMS1
cmsSetAlarmCodes(gamutColor_r >> 8, gamutColor_g >> 8, gamutColor_b >> 8);
#elif HAVE_LIBLCMS2
cmsUInt16Number newAlarmCodes[cmsMAXCHANNELS] = {0};
newAlarmCodes[0] = gamutColor_r;
newAlarmCodes[1] = gamutColor_g;
newAlarmCodes[2] = gamutColor_b;
newAlarmCodes[3] = ~0;
cmsSetAlarmCodes(newAlarmCodes);
#endif
}
if ( bpc ) {
dwFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
#if defined(cmsFLAGS_PRESERVEBLACK)
if ( preserveBlack ) {
dwFlags |= cmsFLAGS_PRESERVEBLACK;
}
#endif // defined(cmsFLAGS_PRESERVEBLACK)
transf = cmsCreateProofingTransform( ColorProfileImpl::getSRGBProfile(), TYPE_BGRA_8, hprof, TYPE_BGRA_8, proofProf, intent, proofIntent, dwFlags );
} else if ( hprof ) {
ParamComboBox::ParamComboBox(const gchar *name, const gchar *guitext, const gchar *desc,
const Parameter::_scope_t scope, bool gui_hidden, const gchar *gui_tip,
Inkscape::Extension::Extension *ext, Inkscape::XML::Node *xml)
: Parameter(name, guitext, desc, scope, gui_hidden, gui_tip, ext)
, _value(NULL)
, _indent(0)
, choices(NULL)
{
const char *xmlval = NULL; // the value stored in XML
if (xml != NULL) {
// Read XML tree to add enumeration items:
for (Inkscape::XML::Node *node = xml->firstChild(); node; node = node->next()) {
char const * chname = node->name();
if (!strcmp(chname, INKSCAPE_EXTENSION_NS "item") || !strcmp(chname, INKSCAPE_EXTENSION_NS "_item")) {
Glib::ustring newguitext, newvalue;
const char * contents = NULL;
if (node->firstChild()) {
contents = node->firstChild()->content();
}
if (contents != NULL) {
// don't translate when 'item' but do translate when '_item'
// NOTE: internal extensions use build_from_mem and don't need _item but
// still need to include if are to be localized
if (!strcmp(chname, INKSCAPE_EXTENSION_NS "_item")) {
if (node->attribute("msgctxt") != NULL) {
newguitext = g_dpgettext2(NULL, node->attribute("msgctxt"), contents);
} else {
newguitext = _(contents);
}
} else {
newguitext = contents;
}
} else
continue;
const char * val = node->attribute("value");
if (val != NULL) {
newvalue = val;
} else {
newvalue = contents;
}
if ( (!newguitext.empty()) && (!newvalue.empty()) ) { // logical error if this is not true here
choices = g_slist_append( choices, new enumentry(newvalue, newguitext) );
}
}
}
// Initialize _value with the default value from xml
// for simplicity : default to the contents of the first xml-child
if (xml->firstChild() && xml->firstChild()->firstChild()) {
xmlval = xml->firstChild()->attribute("value");
}
const char *indent = xml->attribute("indent");
if (indent != NULL) {
_indent = atoi(indent) * 12;
}
}
gchar * pref_name = this->pref_name();
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Glib::ustring paramval = prefs ? prefs->getString(extension_pref_root + pref_name) : "";
g_free(pref_name);
if (!paramval.empty()) {
_value = g_strdup(paramval.data());
} else if (xmlval) {
_value = g_strdup(xmlval);
}
}