src/extension/internal/filter/filter-file.cpp

   1 /*
   2  * Copyright (C) 2008 Authors:
   3  *   Ted Gould <ted@gould.cx>
   4  *
   5  * Released under GNU GPL, read the file 'COPYING' for more information
   6  */
   7
   8 #include "filter.h"
   9
  10 #include "io/sys.h"
  11 #include "io/inkscapestream.h"
  12
  13 /* Directory includes */
  14 #include "path-prefix.h"
  15 #include "inkscape.h"
  16
  17 /* Extension */
  18 #include "extension/extension.h"
  19 #include "extension/system.h"
  20
  21 /* System includes */
  22 #include <glibmm/i18n.h>
  23
  24 namespace Inkscape {
  25 namespace Extension {
  26 namespace Internal {
  27 namespace Filter {
  28
  29 void
  30 Filter::filters_all_files (void)
  31 {
  32         filters_load_dir(INKSCAPE_FILTERDIR, _("Bundled"));
  33         filters_load_dir(profile_path("filters"), _("Personal"));
  34
  35         return;
  36 }
  37
  38 #define INKSCAPE_FILTER_FILE  ".svg"
  39
  40 void
  41 Filter::filters_load_dir (gchar * dirname, gchar * menuname)
  42 {
  43     if (!dirname) {
  44         g_warning(_("Null external module directory name.  Filters will not be loaded."));
  45         return;
  46     }
  47
  48     if (!Glib::file_test(std::string(dirname), Glib::FILE_TEST_EXISTS | Glib::FILE_TEST_IS_DIR)) {
  49         return;
  50     }
  51
  52     GError *err;
  53     GDir *directory = g_dir_open(dirname, 0, &err);
  54     if (!directory) {
  55         gchar *safeDir = Inkscape::IO::sanitizeString(dirname);
  56         g_warning(_("Modules directory (%s) is unavailable.  External modules in that directory will not be loaded."), safeDir);
  57         g_free(safeDir);
  58         return;
  59     }
  60
  61     gchar *filename;
  62     while ((filename = (gchar *)g_dir_read_name(directory)) != NULL) {
  63         if (strlen(filename) < strlen(INKSCAPE_FILTER_FILE)) {
  64             continue;
  65         }
  66
  67         if (strcmp(INKSCAPE_FILTER_FILE, filename + (strlen(filename) - strlen(INKSCAPE_FILTER_FILE)))) {
  68             continue;
  69         }
  70
  71         gchar *pathname = g_build_filename(dirname, filename, NULL);
  72         filters_load_file(pathname, menuname);
  73         g_free(pathname);
  74     }
  75
  76     g_dir_close(directory);
  77
  78         return;
  79 }
  80
  81 void
  82 Filter::filters_load_file (gchar * filename, gchar * menuname)
  83 {
  84     Inkscape::XML::Document *doc = sp_repr_read_file(filename, INKSCAPE_EXTENSION_URI);
  85         if (doc == NULL) {
  86                 g_warning("File (%s) is not parseable as XML.  Ignored.", filename);
  87                 return;
  88         }
  89
  90         Inkscape::XML::Node * root = doc->root();
  91         if (strcmp(root->name(), "svg:svg")) {
  92                 Inkscape::GC::release(doc);
  93                 g_warning("File (%s) is not SVG.  Ignored.", filename);
  94                 return;
  95         }
  96
  97         for (Inkscape::XML::Node * child = root->firstChild();
  98                         child != NULL; child = child->next()) {
  99                 if (!strcmp(child->name(), "svg:defs")) {
 100                         for (Inkscape::XML::Node * defs = child->firstChild();
 101                                         defs != NULL; defs = defs->next()) {
 102                                 if (!strcmp(defs->name(), "svg:filter")) {
 103                                         filters_load_node(defs, menuname);
 104                                 } // oh!  a filter
 105                         } //defs
 106                 } // is defs
 107         } // children of root
 108
 109         Inkscape::GC::release(doc);
 110         return;
 111 }
 112
 113 #include "extension/internal/clear-n_.h"
 114
 115 class mywriter : public Inkscape::IO::BasicWriter {
 116         Glib::ustring _str;
 117 public:
 118         void close(void);
 119         void flush(void);
 120         void put (gunichar ch);
 121         gchar const * c_str (void) { return _str.c_str(); }
 122 };
 123
 124 void mywriter::close (void) { return; }
 125 void mywriter::flush (void) { return; }
 126 void mywriter::put (gunichar ch) { _str += ch; }
 127
 128
 129 void
 130 Filter::filters_load_node (Inkscape::XML::Node * node, gchar * menuname)
 131 {
 132         gchar const * label = node->attribute("inkscape:label");
 133         gchar const * id = node->attribute("id");
 134
 135         if (label == NULL) {
 136                 label = id;
 137         }
 138
 139         gchar * xml_str = g_strdup_printf(
 140         "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
 141             "<name>%s</name>\n"
 142             "<id>org.inkscape.effect.filter.%s</id>\n"
 143             "<effect>\n"
 144                 "<object-type>all</object-type>\n"
 145                 "<effects-menu>\n"
 146                     "<submenu name=\"" N_("Filter") "\">\n"
 147                                                 "<submenu name=\"%s\"/>\n"
 148                                         "</submenu>\n"
 149                 "</effects-menu>\n"
 150             "</effect>\n"
 151         "</inkscape-extension>\n", label, id, menuname);
 152
 153         mywriter writer;
 154         sp_repr_write_stream(node, writer, 0, FALSE, g_quark_from_static_string("svg"), 0, 0);
 155
 156     Inkscape::Extension::build_from_mem(xml_str, new Filter::Filter(g_strdup(writer.c_str())));
 157         g_free(xml_str);
 158     return;
 159 }
 160
 161 }; /* namespace Filter */
 162 }; /* namespace Internal */
 163 }; /* namespace Extension */
 164 }; /* namespace Inkscape */
 165