3220e574aa53c97511b58a102d0316f204c876a6
1 /*
2 * Authors:
3 * Ted Gould <ted@gould.cx>
4 *
5 * Copyright (C) 2006 Johan Engelen <johan@shouraizou.nl>
6 * Copyright (C) 2002-2004 Authors
7 *
8 * Released under GNU GPL, read the file 'COPYING' for more information
9 */
11 #include "document.h"
12 #include "implementation/implementation.h"
13 #include "output.h"
15 #include "prefdialog.h"
17 /* Inkscape::Extension::Output */
19 namespace Inkscape {
20 namespace Extension {
22 /**
23 \return None
24 \brief Builds a SPModuleOutput object from a XML description
25 \param module The module to be initialized
26 \param repr The XML description in a Inkscape::XML::Node tree
28 Okay, so you want to build a SPModuleOutput object.
30 This function first takes and does the build of the parent class,
31 which is SPModule. Then, it looks for the <output> section of the
32 XML description. Under there should be several fields which
33 describe the output module to excruciating detail. Those are parsed,
34 copied, and put into the structure that is passed in as module.
35 Overall, there are many levels of indentation, just to handle the
36 levels of indentation in the XML file.
37 */
38 Output::Output (Inkscape::XML::Node * in_repr, Implementation::Implementation * in_imp) : Extension(in_repr, in_imp)
39 {
40 mimetype = NULL;
41 extension = NULL;
42 filetypename = NULL;
43 filetypetooltip = NULL;
44 dataloss = TRUE;
46 if (repr != NULL) {
47 Inkscape::XML::Node * child_repr;
49 child_repr = sp_repr_children(repr);
51 while (child_repr != NULL) {
52 if (!strcmp(child_repr->name(), INKSCAPE_EXTENSION_NS "output")) {
53 child_repr = sp_repr_children(child_repr);
54 while (child_repr != NULL) {
55 char const * chname = child_repr->name();
56 if (!strncmp(chname, INKSCAPE_EXTENSION_NS_NC, strlen(INKSCAPE_EXTENSION_NS_NC))) {
57 chname += strlen(INKSCAPE_EXTENSION_NS);
58 }
59 if (chname[0] == '_') /* Allow _ for translation of tags */
60 chname++;
61 if (!strcmp(chname, "extension")) {
62 g_free (extension);
63 extension = g_strdup(sp_repr_children(child_repr)->content());
64 }
65 if (!strcmp(chname, "mimetype")) {
66 g_free (mimetype);
67 mimetype = g_strdup(sp_repr_children(child_repr)->content());
68 }
69 if (!strcmp(chname, "filetypename")) {
70 g_free (filetypename);
71 filetypename = g_strdup(sp_repr_children(child_repr)->content());
72 }
73 if (!strcmp(chname, "filetypetooltip")) {
74 g_free (filetypetooltip);
75 filetypetooltip = g_strdup(sp_repr_children(child_repr)->content());
76 }
77 if (!strcmp(chname, "dataloss")) {
78 if (!strcmp(sp_repr_children(child_repr)->content(), "false")) {
79 dataloss = FALSE;
80 }
81 }
83 child_repr = sp_repr_next(child_repr);
84 }
86 break;
87 }
89 child_repr = sp_repr_next(child_repr);
90 }
92 }
93 }
95 /**
96 \brief Destroy an output extension
97 */
98 Output::~Output (void)
99 {
100 g_free(mimetype);
101 g_free(extension);
102 g_free(filetypename);
103 g_free(filetypetooltip);
104 return;
105 }
107 /**
108 \return Whether this extension checks out
109 \brief Validate this extension
111 This function checks to make sure that the output extension has
112 a filename extension and a MIME type. Then it calls the parent
113 class' check function which also checks out the implmentation.
114 */
115 bool
116 Output::check (void)
117 {
118 if (extension == NULL)
119 return FALSE;
120 if (mimetype == NULL)
121 return FALSE;
123 return Extension::check();
124 }
126 /**
127 \return IETF mime-type for the extension
128 \brief Get the mime-type that describes this extension
129 */
130 gchar *
131 Output::get_mimetype(void)
132 {
133 return mimetype;
134 }
136 /**
137 \return Filename extension for the extension
138 \brief Get the filename extension for this extension
139 */
140 gchar *
141 Output::get_extension(void)
142 {
143 return extension;
144 }
146 /**
147 \return The name of the filetype supported
148 \brief Get the name of the filetype supported
149 */
150 gchar *
151 Output::get_filetypename(void)
152 {
153 if (filetypename != NULL)
154 return filetypename;
155 else
156 return get_name();
157 }
159 /**
160 \return Tooltip giving more information on the filetype
161 \brief Get the tooltip for more information on the filetype
162 */
163 gchar *
164 Output::get_filetypetooltip(void)
165 {
166 return filetypetooltip;
167 }
169 /**
170 \return A dialog to get settings for this extension
171 \brief Create a dialog for preference for this extension
173 Calls the implementation to get the preferences.
174 */
175 bool
176 Output::prefs (void)
177 {
178 if (!loaded())
179 set_state(Extension::STATE_LOADED);
180 if (!loaded()) return false;
182 Gtk::Widget * controls;
183 controls = imp->prefs_output(this);
184 if (controls == NULL) {
185 // std::cout << "No preferences for Output" << std::endl;
186 return true;
187 }
189 PrefDialog * dialog = new PrefDialog(this->get_name(), this->get_help(), controls);
190 int response = dialog->run();
191 dialog->hide();
193 delete dialog;
195 if (response == Gtk::RESPONSE_OK) return true;
196 return false;
197 }
199 /**
200 \return None
201 \brief Save a document as a file
202 \param doc Document to save
203 \param uri File to save the document as
205 This function does a little of the dirty work involved in saving
206 a document so that the implementation only has to worry about geting
207 bits on the disk.
209 The big thing that it does is remove and readd the fields that are
210 only used at runtime and shouldn't be saved. One that may surprise
211 people is the output extension. This is not saved so that the IDs
212 could be changed, and old files will still work properly.
213 */
214 void
215 Output::save (SPDocument * doc, const gchar * uri)
216 {
217 try {
218 imp->save(this, doc, uri);
219 }
220 catch (...) {
221 throw;
222 }
224 return;
225 }
227 } } /* namespace Inkscape, Extension */
229 /*
230 Local Variables:
231 mode:c++
232 c-file-style:"stroustrup"
233 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
234 indent-tabs-mode:nil
235 fill-column:99
236 End:
237 */
238 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :