From 179fa413b047bede6e32109e2ce82437c5fb8d34 Mon Sep 17 00:00:00 2001 From: MenTaLguY Date: Mon, 16 Jan 2006 02:36:01 +0000 Subject: moving trunk for module inkscape (bzr r1) --- src/extension/output.cpp | 262 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 262 insertions(+) create mode 100644 src/extension/output.cpp (limited to 'src/extension/output.cpp') diff --git a/src/extension/output.cpp b/src/extension/output.cpp new file mode 100644 index 000000000..5f740bbff --- /dev/null +++ b/src/extension/output.cpp @@ -0,0 +1,262 @@ +/* + * Authors: + * Ted Gould + * + * Copyright (C) 2002-2004 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include "document.h" +#include "implementation/implementation.h" +#include "output.h" + +#include "prefdialog.h" + +/* Inkscape::Extension::Output */ + +namespace Inkscape { +namespace Extension { + +/** + \return None + \brief Builds a SPModuleOutput object from a XML description + \param module The module to be initialized + \param repr The XML description in a Inkscape::XML::Node tree + + Okay, so you want to build a SPModuleOutput object. + + This function first takes and does the build of the parent class, + which is SPModule. Then, it looks for the section of the + XML description. Under there should be several fields which + describe the output module to excruciating detail. Those are parsed, + copied, and put into the structure that is passed in as module. + Overall, there are many levels of indentation, just to handle the + levels of indentation in the XML file. +*/ +Output::Output (Inkscape::XML::Node * in_repr, Implementation::Implementation * in_imp) : Extension(in_repr, in_imp) +{ + mimetype = NULL; + extension = NULL; + filetypename = NULL; + filetypetooltip = NULL; + dataloss = TRUE; + + if (repr != NULL) { + Inkscape::XML::Node * child_repr; + + child_repr = sp_repr_children(repr); + + while (child_repr != NULL) { + if (!strcmp(child_repr->name(), "output")) { + child_repr = sp_repr_children(child_repr); + while (child_repr != NULL) { + char const * chname = child_repr->name(); + if (chname[0] == '_') /* Allow _ for translation of tags */ + chname++; + if (!strcmp(chname, "extension")) { + g_free (extension); + extension = g_strdup(sp_repr_children(child_repr)->content()); + } + if (!strcmp(chname, "mimetype")) { + g_free (mimetype); + mimetype = g_strdup(sp_repr_children(child_repr)->content()); + } + if (!strcmp(chname, "filetypename")) { + g_free (filetypename); + filetypename = g_strdup(sp_repr_children(child_repr)->content()); + } + if (!strcmp(chname, "filetypetooltip")) { + g_free (filetypetooltip); + filetypetooltip = g_strdup(sp_repr_children(child_repr)->content()); + } + if (!strcmp(chname, "dataloss")) { + if (!strcmp(sp_repr_children(child_repr)->content(), "FALSE")) { + dataloss = FALSE; + } + } + + child_repr = sp_repr_next(child_repr); + } + + break; + } + + child_repr = sp_repr_next(child_repr); + } + + } +} + +/** + \brief Destroy an output extension +*/ +Output::~Output (void) +{ + g_free(mimetype); + g_free(extension); + g_free(filetypename); + g_free(filetypetooltip); + return; +} + +/** + \return Whether this extension checks out + \brief Validate this extension + + This function checks to make sure that the output extension has + a filename extension and a MIME type. Then it calls the parent + class' check function which also checks out the implmentation. +*/ +bool +Output::check (void) +{ + if (extension == NULL) + return FALSE; + if (mimetype == NULL) + return FALSE; + + return Extension::check(); +} + +/** + \return IETF mime-type for the extension + \brief Get the mime-type that describes this extension +*/ +gchar * +Output::get_mimetype(void) +{ + return mimetype; +} + +/** + \return Filename extension for the extension + \brief Get the filename extension for this extension +*/ +gchar * +Output::get_extension(void) +{ + return extension; +} + +/** + \return The name of the filetype supported + \brief Get the name of the filetype supported +*/ +gchar * +Output::get_filetypename(void) +{ + if (filetypename != NULL) + return filetypename; + else + return get_name(); +} + +/** + \return Tooltip giving more information on the filetype + \brief Get the tooltip for more information on the filetype +*/ +gchar * +Output::get_filetypetooltip(void) +{ + return filetypetooltip; +} + +/** + \return A dialog to get settings for this extension + \brief Create a dialog for preference for this extension + + Calls the implementation to get the preferences. +*/ +bool +Output::prefs (void) +{ + if (!loaded()) + set_state(Extension::STATE_LOADED); + if (!loaded()) return false; + + Gtk::Widget * controls; + controls = imp->prefs_output(this); + if (controls == NULL) { + // std::cout << "No preferences for Output" << std::endl; + return true; + } + + PrefDialog * dialog = new PrefDialog(this->get_name(), controls); + int response = dialog->run(); + dialog->hide(); + + delete dialog; + + if (response == Gtk::RESPONSE_OK) return true; + return false; +} + +/** + \return None + \brief Save a document as a file + \param doc Document to save + \param uri File to save the document as + + This function does a little of the dirty work involved in saving + a document so that the implementation only has to worry about geting + bits on the disk. + + The big thing that it does is remove and readd the fields that are + only used at runtime and shouldn't be saved. One that may surprise + people is the output extension. This is not saved so that the IDs + could be changed, and old files will still work properly. + + After the file is saved by the implmentation the output_extension + and dataloss variables are recreated. The output_extension is set + to this extension so that future saves use this extension. Dataloss + is set so that a warning will occur on closing the document that + there may be some dataloss from this extension. +*/ +void +Output::save (SPDocument * doc, const gchar * uri) +{ + bool modified = false; + Inkscape::XML::Node * repr = sp_document_repr_root(doc); + + gboolean saved = sp_document_get_undo_sensitive(doc); + sp_document_set_undo_sensitive (doc, FALSE); + repr->setAttribute("inkscape:output_extension", NULL); + repr->setAttribute("inkscape:dataloss", NULL); + if (repr->attribute("sodipodi:modified") != NULL) + modified = true; + repr->setAttribute("sodipodi:modified", NULL); + sp_document_set_undo_sensitive (doc, saved); + + try { + imp->save(this, doc, uri); + } + catch (...) { + if (modified) + repr->setAttribute("sodipodi:modified", "true"); + throw; + } + + saved = sp_document_get_undo_sensitive(doc); + sp_document_set_undo_sensitive (doc, FALSE); + repr->setAttribute("inkscape:output_extension", get_id()); + if (dataloss) { + repr->setAttribute("inkscape:dataloss", "true"); + } + sp_document_set_undo_sensitive (doc, saved); + + return; +} + +} } /* namespace Inkscape, Extension */ + +/* + 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 : -- cgit v1.2.3