---

swmodule.h

/******************************************************************************
 *  swmodule.h  - code for base class 'module'.  Module is the basis for all
 *                types of modules (e.g. texts, commentaries, maps, lexicons,
 *                etc.)
 *
 * $Id: swmodule_8h-source.html,v 1.7 2002/06/20 20:23:10 mgruner Exp $
 *
 * Copyright 1998 CrossWire Bible Society (http://www.crosswire.org)
 *      CrossWire Bible Society
 *      P. O. Box 2528
 *      Tempe, AZ  85280-2528
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation version 2.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 */

#ifndef SWMODULE_H
#define SWMODULE_H

#include <swdisp.h>
#include <swkey.h>
#include <listkey.h>
#include <swfilter.h>
#include <swconfig.h>
#include <swcacher.h>
#include <list>

#include <defs.h>
#include <multimapwdef.h>

#define FILTERPAD 80

using namespace std;

typedef list < SWFilter * >FilterList;

typedef map < string, string, less < string > > AttributeValue;
typedef map < string, AttributeValue, less < string > > AttributeList;
typedef map < string, AttributeList, less < string > > AttributeTypeList;

#define SWTextDirection char
#define SWTextEncoding char
#define SWTextMarkup char

enum {DIRECTION_LTR = 0, DIRECTION_RTL, DIRECTION_BIDI};
enum {FMT_UNKNOWN = 0, FMT_PLAIN, FMT_THML, FMT_GBF, FMT_HTML, FMT_HTMLHREF, FMT_RTF, FMT_OSIS};
enum {ENC_UNKNOWN = 0, ENC_LATIN1, ENC_UTF8, ENC_SCSU, ENC_UTF16, ENC_RTF, ENC_HTML};

class SWDLLEXPORT SWModule : public SWCacher {

protected:

  ConfigEntMap ownConfig;
  ConfigEntMap *config;
  mutable AttributeTypeList entryAttributes;
  mutable bool procEntAttr;

  char error;
  bool skipConsecutiveLinks;

  SWKey *key;

  ListKey listkey;
  char *modname;
  char *moddesc;
  char *modtype;
  char *modlang;  

  char direction;
  char markup;
  char encoding;

  SWDisplay *disp;

  static SWDisplay rawdisp;
  char *entrybuf;
  unsigned long entrybufallocsize;

  FilterList *stripFilters;

  FilterList *rawFilters;

  FilterList *renderFilters;

  FilterList *optionFilters;

  FilterList *encodingFilters;

  int entrySize;

public:
  static void nullPercent (char percent, void *userData);
  bool terminateSearch;
  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);
  virtual ~ SWModule ();
  virtual char Error ();
  virtual const bool isUnicode() const {return (encoding == (char)ENC_UTF8 || encoding == (char)ENC_SCSU);}

  // These methods are useful for modules that come from a standard SWORD install (most do).
  // SWMgr will call setConfig.  The user may use getConfig and getConfigEntry (if they
  // are not comfortable with, or don't wish to use  stl maps).
  virtual const ConfigEntMap &getConfig() const { return *config; }
  virtual void setConfig(ConfigEntMap *config);
  virtual const char *getConfigEntry(const char *key) const;

  virtual const int getEntrySize() const {return entrySize;}
  virtual char SetKey (const SWKey *ikey);
  virtual char SetKey (const SWKey &ikey);
  virtual SWKey & Key () const {
    return *key;
  }
  virtual char Key (const SWKey & ikey) {
    return SetKey (ikey);
  }
  virtual const char *KeyText (const char *imodtype = 0);
  virtual char Display ();
  virtual SWDisplay *Disp (SWDisplay * idisp = 0);
  virtual char *Name (const char *imodname = 0);
  virtual char *Description (const char *imoddesc = 0);
  virtual char *Type (const char *imodtype = 0);
  virtual char Direction(signed char newdir = -1);
  virtual char Encoding(signed char enc = -1);
  virtual char Markup(signed char enc = -1);
  virtual char *Lang (const char *imodlang = 0);

  // search methods

  virtual ListKey & Search (const char *istr, int searchType = 0, int flags = 0,
                  SWKey * scope = 0,
                  bool * justCheckIfSupported = 0,
                  void (*percent) (char, void *) = &nullPercent,
                  void *percentUserData = 0);
  virtual signed char createSearchFramework () {
    return 0;
  }                             // special search framework
  virtual bool hasSearchFramework () {
    return false;
  }                             // special search framework
  virtual bool isSearchOptimallySupported (const char *istr, int searchType,
                                           int flags, SWKey * scope) {
      bool retVal = false;
      Search (istr, searchType, flags, scope, &retVal);
      return retVal;
  }
  virtual SWKey *CreateKey ();
  virtual operator const char *();
  virtual char *getRawEntry () = 0;
  virtual operator SWKey & () {
    return *key;
  }
  virtual operator SWKey *() {
    return key;
  }


  // write interface ----------------------------
  virtual bool isWritable () {
    return false;
  }
  static signed char createModule (const char *) {
    return -1;
  }
  virtual SWModule & setentry (const char *inbuf, long len) {
    return *this;
  }
  virtual SWModule & operator << (const char *) {
    return *this;
  }
  virtual SWModule & operator << (const SWKey *) {
    return *this;
  }
  virtual void deleteEntry () {
  }
  // end write interface ------------------------

  virtual SWModule & operator -= (int decrement);
  virtual SWModule & operator += (int increment);
  virtual SWModule & operator++ (int) {
    return *this += 1;
  }
  virtual SWModule & operator-- (int) {
    return *this -= 1;
  }
  virtual SWModule & operator = (SW_POSITION p);
  virtual SWModule & AddRenderFilter (SWFilter * newfilter) {
    renderFilters->push_back (newfilter);
    return *this;
  }
  virtual SWModule & RemoveRenderFilter (SWFilter * oldfilter) {
    renderFilters->remove (oldfilter);
    return *this;
  }
  virtual SWModule & ReplaceRenderFilter (SWFilter * oldfilter, SWFilter * newfilter) {
    FilterList::iterator iter;
    for (iter = renderFilters->begin(); iter != renderFilters->end(); iter++)
        if (*iter == oldfilter)
                *iter = newfilter;
    return *this;
  }
  virtual void renderFilter (char *buf, long size, SWKey *key) {
        filterBuffer(renderFilters, buf, size, key);
  }
  virtual SWModule & AddEncodingFilter (SWFilter * newfilter) {
    encodingFilters->push_back (newfilter);
    return *this;
  }
  virtual SWModule & RemoveEncodingFilter (SWFilter * oldfilter) {
    encodingFilters->remove (oldfilter);
    return *this;
  }
  virtual SWModule & ReplaceEncodingFilter (SWFilter * oldfilter, SWFilter * newfilter) {
    FilterList::iterator iter;
    for (iter = encodingFilters->begin(); iter != encodingFilters->end(); iter++)
        if (*iter == oldfilter)
                *iter = newfilter;
    return *this;
  }
  virtual void encodingFilter (char *buf, long size, SWKey *key) {
        filterBuffer(encodingFilters, buf, size, key);
  }
  virtual SWModule & AddStripFilter (SWFilter * newfilter) {
    stripFilters->push_back (newfilter);
    return *this;
  }
  virtual void stripFilter (char *buf, long size, SWKey *key) {
        filterBuffer(stripFilters, buf, size, key);
  }
  virtual SWModule & AddRawFilter (SWFilter * newfilter) {
    rawFilters->push_back (newfilter);
    return *this;
  }
  virtual void filterBuffer (FilterList *filters, char *buf, long size, SWKey *key) {
        FilterList::iterator it;
        for (it = filters->begin(); it != filters->end(); it++) {
                (*it)->ProcessText(buf, size, key, this);
        }
  }
  virtual void rawFilter (char *buf, long size, SWKey *key) {
        buf[size] = 0;
        filterBuffer(rawFilters, buf, size, key);
  }
  virtual SWModule & AddOptionFilter (SWFilter * newfilter) {
    optionFilters->push_back (newfilter);
    return *this;
  }
  virtual void optionFilter (char *buf, long size, SWKey *key) {
        filterBuffer(optionFilters, buf, size, key);
  }
  virtual const char *StripText (char *buf = 0, int len = -1);
  virtual const char *RenderText (char *buf = 0, int len = -1, bool render = true);
  virtual const char *StripText (SWKey * tmpKey);
  virtual const char *RenderText (SWKey * tmpKey);

  virtual void setSkipConsecutiveLinks(bool val) { skipConsecutiveLinks = val; }
  virtual bool getSkipConsecutiveLinks() { return skipConsecutiveLinks; }
  virtual AttributeTypeList &getEntryAttributes() const { return entryAttributes; }
  virtual void processEntryAttributes(bool val) const { procEntAttr = val; }
  virtual bool isProcessEntryAttributes() const { return procEntAttr; }
};


#endif

---