File indexing completed on 2024-04-28 15:35:15

 /***************************************************************************
  *   Copyright (C) 2004 by Tomas Mecir                                     *
  *   kmuddy@kmuddy.org                                                     *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   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 Library General Public License for more details.                  *
  ***************************************************************************/
 #ifndef CMXPSTATE_H
 #define CMXPSTATE_H
 
 #include <list>
 #include <map>
 #include <string>
 
 #include "libmxp.h"
 
 using namespace std;
 
 struct closingTag {
   //tag name (lowercase)
   string name;
   //closing result, if there's exactly one
   mxpResult *closingresult;
   //usually only zero or one element, but sometimes more :-)
   list<mxpResult *> *closingresults;
 };
 
 enum mxpMode {
   openMode = 0,
   secureMode,
   lockedMode
 };
 
 class cResultHandler;
 class cElementManager;
 class cEntityManager;
 
 /**
 This class provides most of the "intelligence" of the library - others feed it with what they
 got, and this class decides what to send to the client and all that :-)
 
 In particular:
 Stores state variables of the MXP parser - current font/color/..., as well as a list of
 currently open tags. Also provides conversion from tag properties to mxpState.
 Also handles tag closing and auto-closing.
 
 It's up to the caller to verify that bad things don't happen - errors will be sent if
 secure tags are sent in open mode and so...
 
 @author Tomas Mecir
 */
 
 class cMXPState {
 public:
   /** constructor */
   cMXPState (cResultHandler *resh, cElementManager *elm, cEntityManager *enm);
   /** destructor */
   ~cMXPState ();
 
 //some user-adjustable parameters
   void setDefaultText (const string &font, int size, bool _bold, bool _italic, bool _underline,
       bool _strikeout, RGB fg, RGB bg);
   void setHeaderParams (int which, const string &font, int size, bool _bold, bool _italic,
       bool _underline, bool _strikeout, RGB fg, RGB bg);
   void setDefaultGaugeColor (RGB color);
   void setNonProportFont (string font);
   void setClient (string name, string version);
 
   //SUPPORTS stuff
   void supportsLink (bool supports);
   void supportsGauge (bool supports);
   void supportsStatus (bool supports);
   void supportsSound (bool supports);
   void supportsFrame (bool supports);
   void supportsImage (bool supports);
   void supportsRelocate (bool supports);
 
   /** switch current mode and default mode to OPEN - call this before processing any text, if
   you want to better conform to MXP, at the risk of problems with non-MXP MUDs
   No reason to use this on MXP-enabled MUDs though - they will go to secure mode anyway... */
   void switchToOpen ();
 
   //reset everything to default values
   void reset ();
 
 //modes, mode switching
   /** return current mode */
   mxpMode getMXPMode ();
   /** switch mode; IMPORTANT: WILL NOT CLOSE TAGS OR ANYTHING!!! */
   void setMXPMode (mxpMode m);
   /** line tag received - act accordingly */
   void gotLineTag (int number);
   /** we should close all tags - called by gotLineTag, */
   void closeAllTags ();
 
 //regular text
   /** got regular text */
   void gotText (const string &text, bool expandentities = true);
   /** got new-line character */
   void gotNewLine ();
 
 //flags
   /** called when a flagged tag was received, either at its beginning or at its ending; the tag
   may not necessarily follow, as it's possible to flag some text without giving it any more
   attributes */
   void gotFlag (bool begin, string flag);
 
 //value retrieving (so that we can supply default parameters)
   bool isBold () { return bold; };
   bool isItalic () { return italic; };
   bool isUnderline () { return underline; };
   bool isStrikeout () { return strikeout; };
   RGB fgColor () { return fgcolor; };
   RGB bgColor () { return bgcolor; };
   string fontFace () { return curfont; };
   int fontSize () { return cursize; };
 
 //tags:
 //variables
   /** called upon !ENTITY tag (erase==true means erase the variable) */
   void gotVariable (const string &name, const string &value, bool erase = false);
   /** called upon the VAR tag */
   void gotVAR (const string &name);
 
 //text formatting (OPEN tags)
   void gotBOLD ();
   void gotITALIC ();
   void gotUNDERLINE ();
   void gotSTRIKEOUT ();
   void gotCOLOR (RGB fg, RGB bg);
   void gotHIGH ();
   void gotFONT (const string &face, int size, RGB fg, RGB bg);
 //line spacing
   void gotNOBR ();
   void gotP ();
   void gotBR ();
   void gotSBR ();
 //links
   /** got A-link; must wait for closing tag before sending anything to the client */
   void gotA (const string &href, const string &hint, const string &expire);
   /** got SEND-link; must wait for </SEND>, then expand &text; if needed */
   void gotSEND (const string &command, const string &hint, bool prompt, const string &expire);
   void gotEXPIRE (const string &name);
 //version control
   void gotVERSION ();
   void gotSUPPORT (list<string> params);
 //optional tags go next
 //other HTML tags
   /** got one of H1, ..., H6 (thus, which is in range 1..6) */
   void gotHtag (int which);
   void gotHR ();
   void gotSMALL ();
   void gotTT ();
 //MSP compatibility
   void gotSOUND (const string &fname, int vol, int count, int priority, const string &type,
       const string &url);
   void gotMUSIC (const string &fname, int vol, int count, bool contifrereq, const string &type,
       const string &url);
 //gauges / status bars
   void gotGAUGE (const string &entity, const string &maxentity, const string &caption, RGB color);
   void gotSTAT (const string &entity, const string &maxentity, const string &caption);
 //frames and cursor control
   void gotFRAME (const string &name, const string &action, const string &title, bool internal,
       const string &align, int left, int top, int width, int height, bool scrolling,
       bool floating);
   void gotDEST (const string &name, int x = -1, int y = -1, bool eol = false, bool eof = false);
 //crosslinking servers
   void gotRELOCATE (const string &hostname, int port);
   void gotUSER ();
   void gotPASSWORD ();
 //images
   void gotIMAGE (const string &fname, const string &url, const string &type, int height,
       int width, int hspace, int vspace, const string &align, bool ismap);
 
 //closing tags
   /** we got a closing-tag; caller must ensure that everything is okay (i.e. such closing tag
   can exist, tag is elementary (not user-defined), we're in correct mode, ...)
   also, the name should be a shorter variant (e.g. "b", not "bold") */
   void gotClosingTag (const string &name);
 
 //mxpResult handling
   /** create a closing mxpResult; must be called BEFORE applyResult() !!! */
   mxpResult *createClosingResult (mxpResult *what);
   /** apply this result */
   void applyResult (mxpResult *what);
 
 //screen, window and font size, used by FRAME and IMAGE tags
   void setScreenProps (int sx, int sy, int wx, int wy, int fx, int fy);
   /** compute coordinated, input can contain 'c' or '%' as the last parameter */
   int computeCoord (const string &coord, bool isX = true, bool inWindow = false);
 protected:
   /** close this tag :-) and delete the argument */
   void closeTag (closingTag *tag);
   /** add a closing tag to the list of pending closing tags */
   void addClosingTag (const string &name, mxpResult *res = 0, list<mxpResult *> *res2 = 0);
 
   /** stuff common for all tags */
   void commonTagHandler ();
   /** things to do after a tag is processed */
   void commonAfterTagHandler ();
 
   /** redirect output to frame <name> */
   void redirectTo (const string &name);
 
   cResultHandler *results;
   cElementManager *elements;
   cEntityManager *entities;
 
   /** list of closing tags */
   list<closingTag *> closingTags;
 
   /** list of existing frames */
   map<string, bool> frames;
 
   /** current mode */
   mxpMode mode;
   /** current default mode */
   mxpMode defaultmode;
   /** temporary secure mode? */
   bool tempMode;
   /** did we just leave secure mode?*/
   bool wasSecureMode;
 
   //all the parameters:
 
   //text attributes
   bool bold, italic, underline, strikeout;
   RGB fgcolor, bgcolor;
   string curfont;
   int cursize;
   //variables
   bool inVar;
   string varName, varValue;
   //paragraphs
   bool inParagraph;  //in P tag; no method returns this
   bool ignoreNextNewLine;  //after NOBR; no method returns this
   //links
   bool inLink, isALink;
   string lastcmd;
   string linkText;
   bool gotmap;
   //current window
   string curWindow, prevWindow;
 
   //initial LOCKED state?
   bool initiallyLocked;
   
   //currently implemented MXP version
   string mxpVersion;
 
   //user-defined values
   RGB defaultfg, defaultbg;
   string defaultfont;
   int defaultsize;
   char defaultattribs;
 
   string Hfont[6];
   RGB Hfg[6], Hbg[6];
   int Hsize[6];
   char Hattribs[6];
   string ttFont;
   RGB gaugeColor;
 
   string clientName, clientVersion;
 
   //SUPPORTS stuff...
   bool suplink, supgauge, supstatus, supsound, supframe, supimage, suprelocate;
   
   //screen and font parameters
   int sX, sY;      // width/height of the screen
   int wX, wY;      // width/height of the output window
   int fX, fY;      // width/height of character X
 };
 
 #endif