Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members  

swmodule.h

00001 /******************************************************************************
00002  *  swmodule.h  - code for base class 'module'.  Module is the basis for all
00003  *                types of modules (e.g. texts, commentaries, maps, lexicons,
00004  *                etc.)
00005  *
00006  * $Id: swmodule_8h-source.html,v 1.4 2002/01/22 14:20:28 jansorg Exp $
00007  *
00008  * Copyright 1998 CrossWire Bible Society (http://www.crosswire.org)
00009  *      CrossWire Bible Society
00010  *      P. O. Box 2528
00011  *      Tempe, AZ  85280-2528
00012  *
00013  * This program is free software; you can redistribute it and/or modify it
00014  * under the terms of the GNU General Public License as published by the
00015  * Free Software Foundation version 2.
00016  *
00017  * This program is distributed in the hope that it will be useful, but
00018  * WITHOUT ANY WARRANTY; without even the implied warranty of
00019  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00020  * General Public License for more details.
00021  *
00022  */
00023 
00024 #ifndef SWMODULE_H
00025 #define SWMODULE_H
00026 
00027 #include <swdisp.h>
00028 #include <swkey.h>
00029 #include <listkey.h>
00030 #include <swfilter.h>
00031 #include <list>
00032 
00033 #include <defs.h>
00034 
00035 #define FILTERPAD 80
00036 
00037 using namespace std;
00038 
00039 typedef list < SWFilter * >FilterList;
00040 
00041 #define SWTextDirection char
00042 #define SWTextEncoding char
00043 #define SWTextMarkup char
00044 
00045 enum {DIRECTION_LTR = 0, DIRECTION_RTL, DIRECTION_BIDI};
00046 enum {FMT_UNKNOWN = 0, FMT_PLAIN, FMT_THML, FMT_GBF, FMT_HTML, FMT_HTMLHREF, FMT_RTF, FMT_OSIS};
00047 enum {ENC_UNKNOWN = 0, ENC_LATIN1, ENC_UTF8, ENC_SCSU, ENC_UTF16, ENC_RTF, ENC_HTML};
00048 
00057 class SWDLLEXPORT SWModule {
00058 
00059 protected:
00060 
00061   char error;
00062 
00064   SWKey *key;
00065 
00066   ListKey listkey;
00067   char *modname;
00068   char *moddesc;
00069   char *modtype;
00070   char *modlang;  
00071 
00072   char direction;
00073   char markup;
00074   char encoding;
00075 
00077   SWDisplay *disp;
00078 
00079   static SWDisplay rawdisp;
00080   char *entrybuf;
00081 
00083   FilterList *stripFilters;
00084 
00086   FilterList *rawFilters;
00087 
00089   FilterList *renderFilters;
00090 
00092   FilterList *optionFilters;
00093 
00095   FilterList *encodingFilters;
00096 
00097   bool render;
00098   int entrySize;
00099 
00100 public:
00107   static void nullPercent (char percent, void *userData);
00112   bool terminateSearch;
00125   SWModule (const char *imodname = 0, const char *imoddesc = 0, SWDisplay * idisp = 0, char *imodtype = 0, SWTextEncoding encoding = ENC_UNKNOWN, SWTextDirection dir = DIRECTION_LTR, SWTextMarkup markup = FMT_UNKNOWN, const char* modlang = 0);
00128   virtual ~ SWModule ();
00133   virtual char Error ();
00137   virtual const bool isUnicode() const {return (encoding == ENC_UTF8 || encoding == ENC_SCSU);}
00141   virtual const int getEntrySize() const {return entrySize;}
00149   virtual char SetKey (const SWKey *ikey);
00155   virtual char SetKey (const SWKey &ikey);
00159   virtual SWKey & Key () const {
00160     return *key;
00161   }
00168   virtual char Key (const SWKey & ikey) {
00169     return SetKey (ikey);
00170   }
00177   virtual const char *KeyText (const char *imodtype = 0);
00182   virtual char Display ();
00189   virtual SWDisplay *Disp (SWDisplay * idisp = 0);
00196   virtual char *Name (const char *imodname = 0);
00203   virtual char *Description (const char *imoddesc = 0);
00210   virtual char *Type (const char *imodtype = 0);
00217   virtual char Direction(signed char newdir = -1);
00224   virtual char Encoding(signed char enc = -1);
00231   virtual char Markup(signed char enc = -1);
00238   virtual char *Lang (const char *imodlang = 0);
00239 
00240   // search methods
00241 
00253   virtual ListKey & Search (const char *istr, int searchType = 0, int flags = 0,
00254                   SWKey * scope = 0,
00255                   bool * justCheckIfSupported = 0,
00256                   void (*percent) (char, void *) = &nullPercent,
00257                   void *percentUserData = 0);
00261   virtual signed char createSearchFramework () {
00262     return 0;
00263   }                             // special search framework
00267   virtual bool hasSearchFramework () {
00268     return false;
00269   }                             // special search framework
00274   virtual bool isSearchOptimallySupported (const char *istr, int searchType,
00275                                            int flags, SWKey * scope) {
00276       bool retVal = false;
00277       Search (istr, searchType, flags, scope, &retVal);
00278       return retVal;
00279   }
00286   virtual SWKey *CreateKey ();
00290   virtual operator char *();
00295   virtual char *getRawEntry () = 0;
00301   virtual operator SWKey & () {
00302     return *key;
00303   }
00312   virtual operator SWKey *() {
00313     return key;
00314   }
00315 
00316 
00317   // write interface ----------------------------
00321   virtual bool isWritable () {
00322     return false;
00323   }
00328   static signed char createModule (const char *) {
00329     return -1;
00330   }
00335   virtual SWModule & setentry (const char *inbuf, long len) {
00336     return *this;
00337   }
00342   virtual SWModule & operator << (const char *) {
00343     return *this;
00344   }
00349   virtual SWModule & operator << (const SWKey *) {
00350     return *this;
00351   }
00355   virtual void deleteEntry () {
00356   }
00357   // end write interface ------------------------
00358 
00364   virtual SWModule & operator -= (int decrement);
00370   virtual SWModule & operator += (int increment);
00374   virtual SWModule & operator++ (int) {
00375     return *this += 1;
00376   }
00380   virtual SWModule & operator-- (int) {
00381     return *this -= 1;
00382   }
00388   virtual SWModule & operator = (SW_POSITION p);
00393   virtual SWModule & AddRenderFilter (SWFilter * newfilter) {
00394     renderFilters->push_back (newfilter);
00395     return *this;
00396   }
00401   virtual SWModule & RemoveRenderFilter (SWFilter * oldfilter) {
00402     renderFilters->remove (oldfilter);
00403     return *this;
00404   }
00410   virtual SWModule & ReplaceRenderFilter (SWFilter * oldfilter, SWFilter * newfilter) {
00411     FilterList::iterator iter;
00412     for (iter = renderFilters->begin(); iter != renderFilters->end(); iter++)
00413         if (*iter == oldfilter)
00414                 *iter = newfilter;
00415     return *this;
00416   }
00423   virtual void renderFilter (char *buf, long size, SWKey *key) {
00424         filterBuffer(renderFilters, buf, size, key);
00425   }
00430   virtual SWModule & AddEncodingFilter (SWFilter * newfilter) {
00431     encodingFilters->push_back (newfilter);
00432     return *this;
00433   }
00438   virtual SWModule & RemoveEncodingFilter (SWFilter * oldfilter) {
00439     encodingFilters->remove (oldfilter);
00440     return *this;
00441   }
00447   virtual SWModule & ReplaceEncodingFilter (SWFilter * oldfilter, SWFilter * newfilter) {
00448     FilterList::iterator iter;
00449     for (iter = encodingFilters->begin(); iter != encodingFilters->end(); iter++)
00450         if (*iter == oldfilter)
00451                 *iter = newfilter;
00452     return *this;
00453   }
00460   virtual void encodingFilter (char *buf, long size, SWKey *key) {
00461         filterBuffer(encodingFilters, buf, size, key);
00462   }
00467   virtual SWModule & AddStripFilter (SWFilter * newfilter) {
00468     stripFilters->push_back (newfilter);
00469     return *this;
00470   }
00477   virtual void stripFilter (char *buf, long size, SWKey *key) {
00478         filterBuffer(stripFilters, buf, size, key);
00479   }
00484   virtual SWModule & AddRawFilter (SWFilter * newfilter) {
00485     rawFilters->push_back (newfilter);
00486     return *this;
00487   }
00495   virtual void filterBuffer (FilterList *filters, char *buf, long size, SWKey *key) {
00496         FilterList::iterator it;
00497         for (it = filters->begin(); it != filters->end(); it++) {
00498                 (*it)->ProcessText(buf, size, key, this);
00499         }
00500   }
00507   virtual void rawFilter (char *buf, long size, SWKey *key) {
00508         buf[size] = 0;
00509         filterBuffer(rawFilters, buf, size, key);
00510   }
00515   virtual SWModule & AddOptionFilter (SWFilter * newfilter) {
00516     optionFilters->push_back (newfilter);
00517     return *this;
00518   }
00525   virtual void optionFilter (char *buf, long size, SWKey *key) {
00526         filterBuffer(optionFilters, buf, size, key);
00527   }
00535   virtual const char *StripText (char *buf = 0, int len = -1);
00543   virtual const char *RenderText (char *buf = 0, int len = -1);
00549   virtual const char *StripText (SWKey * tmpKey);
00555   virtual const char *RenderText (SWKey * tmpKey);
00556 };
00557 
00558 
00559 #endif

Generated at Tue Jan 22 14:52:48 2002 for The Sword Project by doxygen1.2.9.1 written by Dimitri van Heesch, © 1997-2001