src/trace/trace.h

   1 /*
   2  * A generic interface for plugging different
   3  *  autotracers into Inkscape.
   4  *
   5  * Authors:
   6  *   Bob Jamison <rjamison@titan.com>
   7  *
   8  * Copyright (C) 2004 Bob Jamison
   9  *
  10  * Released under GNU GPL, read the file 'COPYING' for more information
  11  */
  12 #ifndef __TRACE_H__
  13 #define __TRACE_H__
  14
  15 #ifdef HAVE_CONFIG_H
  16 # include "config.h"
  17 #endif
  18
  19 #ifdef HAVE_STDLIB_H
  20 # include <stdlib.h>
  21 #endif
  22
  23 #ifdef HAVE_STRING_H
  24 # include <string.h>
  25 #endif
  26
  27 #include <gtkmm.h>
  28
  29 #include <vector>
  30 #include <sp-shape.h>
  31
  32 struct SPImage;
  33 struct SPItem;
  34
  35 namespace Inkscape {
  36
  37 namespace Trace {
  38
  39
  40
  41 /**
  42  *
  43  */
  44 class TracingEngineResult
  45 {
  46
  47 public:
  48
  49     /**
  50      *
  51      */
  52     TracingEngineResult(char *theStyle, char *thePathData, long theNodeCount)
  53         {
  54         next      = NULL;
  55         style     = strdup(theStyle);
  56         pathData  = strdup(thePathData);
  57         nodeCount = theNodeCount;
  58         }
  59
  60     /**
  61      *
  62      */
  63     virtual ~TracingEngineResult()
  64         {
  65         if (next)
  66             delete next;
  67         if (style)
  68             free(style);
  69         if (pathData)
  70             free(pathData);
  71         }
  72
  73
  74     /**
  75      *
  76      */
  77     char *getStyle()
  78         { return style; }
  79
  80     /**
  81      *
  82      */
  83     char *getPathData()
  84         { return pathData; }
  85
  86     /**
  87      *
  88      */
  89     long getNodeCount()
  90         { return nodeCount; }
  91
  92     /**
  93      *
  94      */
  95     TracingEngineResult *next;
  96
  97 private:
  98
  99     char *style;
 100
 101     char *pathData;
 102
 103     long nodeCount;
 104
 105 };
 106
 107
 108
 109 /**
 110  *
 111  */
 112 class TracingEngine
 113 {
 114
 115     public:
 116
 117     /**
 118      *
 119      */
 120     TracingEngine()
 121         {}
 122
 123     /**
 124      *
 125      */
 126     virtual ~TracingEngine()
 127         {}
 128
 129     /**
 130      *  This is the working method of this interface, and all
 131      *  implementing classes.  Take a GdkPixbuf, trace it, and
 132      *  return a style attribute and the path data that is
 133      *  compatible with the d="" attribute
 134      *  of an SVG <path> element.
 135      */
 136     virtual  TracingEngineResult *trace(Glib::RefPtr<Gdk::Pixbuf> pixbuf,
 137                                         int *nrPaths)
 138         { return NULL; }
 139
 140
 141     /**
 142      *  Abort the thread that is executing getPathDataFromPixbuf()
 143      */
 144     virtual void abort()
 145         {}
 146
 147
 148
 149 };//class TracingEngine
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159 /**
 160  *  This simple class allows a generic wrapper around a given
 161  *  TracingEngine object.  Its purpose is to provide a gateway
 162  *  to a variety of tracing engines, while maintaining a
 163  *  consistent interface.
 164  */
 165 class Tracer
 166 {
 167
 168 public:
 169
 170
 171     /**
 172      *
 173      */
 174     Tracer()
 175         {
 176         engine       = NULL;
 177         sioxEnabled  = false;
 178         }
 179
 180
 181
 182     /**
 183      *
 184      */
 185     ~Tracer()
 186         {}
 187
 188
 189     /**
 190      *  A convenience method to allow other software to 'see' the
 191      *  same image that this class sees.
 192      */
 193     Glib::RefPtr<Gdk::Pixbuf> getSelectedImage();
 194
 195     /**
 196      * This is the main working method.  Trace the selected image, if
 197      * any, and create a <path> element from it, inserting it into
 198      * the current document.
 199      */
 200     void trace(TracingEngine *engine);
 201
 202
 203     /**
 204      *  Abort the thread that is executing convertImageToPath()
 205      */
 206     void abort();
 207
 208     /**
 209      *  Whether we want to enable SIOX subimage selection
 210      */
 211     void enableSiox(bool enable);
 212
 213
 214 private:
 215
 216     /**
 217      * This is the single path code that is called by its counterpart above.
 218      */
 219     void traceThread();
 220
 221     /**
 222      * This is true during execution. Setting it to false (like abort()
 223      * does) should inform the threaded code that it needs to stop
 224      */
 225     bool keepGoing;
 226
 227     /**
 228      *  During tracing, this is Non-null, and refers to the
 229      *  engine that is currently doing the tracing.
 230      */
 231     TracingEngine *engine;
 232
 233     SPImage *getSelectedSPImage();
 234
 235     std::vector<SPShape *> sioxShapes;
 236
 237     bool sioxEnabled;
 238
 239     Glib::RefPtr<Gdk::Pixbuf> sioxProcessImage(
 240            SPImage *img, Glib::RefPtr<Gdk::Pixbuf> origPixbuf);
 241
 242     Glib::RefPtr<Gdk::Pixbuf> lastSioxPixbuf;
 243     Glib::RefPtr<Gdk::Pixbuf> lastOrigPixbuf;
 244
 245 };//class Tracer
 246
 247
 248
 249
 250 } // namespace Trace
 251
 252 } // namespace Inkscape
 253
 254
 255
 256 #endif //__TRACE_H__
 257
 258 //#########################################################################
 259 //# E N D   O F   F I L E
 260 //#########################################################################
 261