intra/xtrasource/page_control.hpp

Go to the documentation of this file.

/* 
  Page Control Class - page_control.hpp
  ----------------------------------------  
  This class represents 
  an abstraction of a web pages menus.  
*/

// Sentry
#ifndef Web_Page_Control_Hpp
#define Web_Page_Control_Hpp

#include "ocXML.h"



class base_functor 
{
 protected:
  page & pg;
 public:
  base_functor(page & ipg):pg(ipg){;}
  virtual ~base_functor(){;}
  
  virtual bool operator()( xmlNode & node )
  {
    return false;
  }
  virtual string getXmlAttribute( xmlNode & node, string name )
  {
    string sRet;           
    node_attr::iterator x = node.attr.find(name);   
    if( x!=node.attr.end())
    {
      sRet=x->second;        
    }   
    return sRet;
  }
};

class top_functor: public base_functor
{
public:
  top_functor(page & ipg):base_functor(ipg){;}
  virtual ~top_functor(){;}
  
  virtual  bool operator()( xmlNode & node )
  {
    cgiScript & script = pg.get_script();
    ocString top = pg.getTop();
    script <<  top.parse("<!--@edit-->");
    if( top.endOfParse() == false )
    {
      ocString editLink =  top.parse("<!--/@edit-->");
      if( isSignedOn )
      {
        // page id
        ocString page_id;
        page_id.append(pg.id());
        // send the edit link
        script <<  editLink.replace("$id$", page_id);
        
      }
      if( top.endOfParse() == false );
      script << top.remainder();
    }
    return true;
  }
};

class end_functor: public base_functor
{
public:
  end_functor(page & ipg):base_functor(ipg){;}
  virtual ~end_functor(){;}
  
  virtual  bool operator()( xmlNode & node )
  {
    cgiScript & script = pg.get_script();
    ocString end = pg.getEnd();

   
    
    // next provide edits for global content
    script <<  end.parse("<!--@edit-->");
    if( end.endOfParse() == false )
    {
      ocString editLink =  end.parse("<!--/@edit-->");
      if( isSignedOn )
      {
        // page id
        ocString page_id;
        page_id.append(pg.id());
        // send the edit link
        script <<  editLink.replace("$id$", page_id);
      }
      else
      {
        // depending on signon do <!--auto--> replacement

      }
      if( end.endOfParse() == false );


      script << end.remainder();
    }
    return true;
  }
};
class menu_functor: public base_functor
{
public:
  menu_functor(page & ipg):base_functor(ipg){;}
  virtual ~menu_functor(){;}
  
  virtual  bool operator()( xmlNode & node )
  {
    string open, close, name;
    node_attr::iterator x = node.attr.find("name");
    if( x!=node.attr.end() )
    {
      name = x->second;
      node_attr::iterator x = node.attr.find("open");
      if( x!=node.attr.end() )
      {
        open=x->second;
        x = node.attr.find("close");   
        if( x!=node.attr.end())
        {        
          close=x->second;
          // start fresh
          cleanHandlerMap( pg.get_menus().handlers );              
          string boundStart, boundEnd;
          // this is for child containers around menu items
          x = node.attr.find("child_open");
          if( x!=node.attr.end()) boundStart = x->second;
          x = node.attr.find("child_close");
          if( x!=node.attr.end()) boundEnd = x->second;
          pg.emitMenu( name, open, close, boundStart, boundEnd ); 
        }   
      }
    }
    return true;  
  }
};

class content_functor: public base_functor
{
public:
  content_functor(page & ipg):base_functor(ipg){;}
  virtual ~content_functor(){;}
  
  virtual  bool operator()( xmlNode & node )
  {
    bool bRet = false;
    string items, replace_tag;
    node_attr::iterator x = node.attr.find("items");
    if( x!=node.attr.end() )
    {

      items=x->second;
      x = node.attr.find("replace-tag");
      if( x==node.attr.end() )
      { // try this
        x = node.attr.find("replace_tag"); 
      }
      if( x!=node.attr.end() )
      {

        replace_tag=x->second;
        string section;
        x = node.attr.find("section");
        if(  x!=node.attr.end() )
        {
          section = x->second;
        }
        bRet = pg.emitContent( items, replace_tag, section );        
      }
      else
      {
        cerr << baseUrl << " no content replace tag" << endl;
      }       
    }
    else
    {
      cerr << baseUrl << " no content items" << endl;
    }
    return bRet;    
  }
};

class spacer_functor: public base_functor
{
public:
  spacer_functor(page & ipg):base_functor(ipg){;}
  virtual ~spacer_functor(){;}
  
  virtual  bool operator()( xmlNode & node )
  {
    bool bRet = false;
    cgiScript & script = pg.get_script();
    string name, replace_tag;        
    node_attr::iterator x = node.attr.find("name");
    if( x!=node.attr.end() )
    {
      name=x->second;
      bRet = true;
      ocString Spacer = pg.getSpacer( name );
      script << Spacer.parse("<!--@edit-->");
      if( Spacer.endOfParse() == false )
      {
        ocString editLink =  Spacer.parse("<!--/@edit-->");
        if( isSignedOn )
        {
          // page id
          ocString page_id;
          page_id.append(pg.id());
          // send the edit link
          script <<  editLink.replace("$id$", page_id);
          
        }
        if( Spacer.endOfParse() == false );
        script << Spacer.remainder();
      }
      
    }
    else
    {
      cout << "no spacer name specified" << endl;
    }
    return bRet;    
  }
};
typedef map< string, base_functor *> pf_map;

class page_control
{
protected:
  
  page & pg;   
  string control; 
  pf_map function_map;
public:
  page_control(page & ipg):pg(ipg),control(pg.loaded_control_string())
  {
    function_map.insert( make_pair( string("top"), new top_functor(pg) ) );
    function_map.insert( make_pair( string("end"), new end_functor(pg) ) );
    function_map.insert( make_pair( string("menu"), new menu_functor(pg) ) );
    function_map.insert( make_pair( string("content"), new content_functor(pg) ) );
    function_map.insert( make_pair( string("spacer"), new spacer_functor(pg) ) );
  }
  ~page_control()
  {
    pf_map::iterator pos;
    for( pos=function_map.begin(); pos!=function_map.end(); ++pos )
    {
      delete pos->second;
    }
  }
  page_control & addOp ( string name,  base_functor * op)
  {
    function_map.insert( make_pair( name, op ) );
    return *this;
  }
  virtual bool emit( void )
  {
    bool bRet = false;
    xmlParser ctrlParse(control);
    ctrlParse.parse();
    node_vector & xnodes = ctrlParse.nodeList();
    int i;

    // start with 1 to skip xml container
    for(i=1;i<xnodes.size();i++)
    {
      xmlNode & node = xnodes[i];
      bRet = emit( node );      
    }
    return bRet;
  }
  
  bool emit( xmlNode & node )
  {
    string name = node.name;
    pf_map::iterator pos = function_map.find(name);
    if( pos!=function_map.end() )
    {
      base_functor & rFunc = * pos->second;      
      rFunc(node);
    }
  }
};

#endif 

---