---

tag.cc

/*
*  Name:      tag.cc
*  Authors:   Angel Jimenez Jimenez
*             Rafael Jesus Alcantara Perez
*  Summary:   HTML base tag
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  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; 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#include <cstdlib>
#include <mpcl/text/codegen/clause_body_string.hh>
#include <mpcl/text/html/tag.hh>


//
//  L O C A L   V A R I A B L E S
//

mpcl::text::codegen::TPatternBasedCodeGenerator*   mpcl::text::html::TTag::_ptCodeGenerator = NULL;


//
//  C O N S T R U C T O R S
//

void mpcl::text::html::TTag::
_setCodeGenerator (const TPatternBasedCodeGenerator& rktCG)
{

  _ptCodeGenerator = (TPatternBasedCodeGenerator*) &rktCG;

}  // setCodeGenerator()


mpcl::text::html::TTag::
TTag (bool gDYNAMICALLY_CREATED)                  :
  IOutputStreamable<>      ()                     ,
  gForwardIdentifier       (true)                 ,
  gHasBeenDynamiclyCreated (gDYNAMICALLY_CREATED) ,
  gIsDynamiclyLoadable     (false)                ,
  gIsQualified             (false)                ,
  gIsRootNode              (false)                ,
  gIsVisible               (true)                 ,
  tAttributeMap            ()
{

  tAttributeMap.bind ("class",                "");
  tAttributeMap.bind ("class-identifier",     "tag");
  tAttributeMap.bind ("id",                   "");
  tAttributeMap.bind ("identifier",           "");
  tAttributeMap.bind ("qualified-identifier", "");
  tAttributeMap.bind ("value",                "");

}  // TTag()


mpcl::text::html::TTag::
TTag (const char* pkcIDENTIFIER, const char* pkcVALUE) :
  IOutputStreamable<>      ()                          ,
  gForwardIdentifier       (true)                      ,
  gHasBeenDynamiclyCreated (false)                     ,
  gIsDynamiclyLoadable     (false)                     ,
  gIsQualified             (false)                     ,
  gIsRootNode              (false)                     ,
  gIsVisible               (true)                      ,
  tAttributeMap            ()
{
  
  tAttributeMap.bind ("class",                "");
  tAttributeMap.bind ("class-identifier",     "tag");
  tAttributeMap.bind ("id",                   pkcIDENTIFIER);
  tAttributeMap.bind ("identifier",           pkcIDENTIFIER);
  tAttributeMap.bind ("qualified-identifier", pkcIDENTIFIER);
  tAttributeMap.bind ("value",                pkcVALUE);

}  // TTag()


mpcl::text::html::TTag::
TTag (const char* pkcIDENTIFIER, bool gDYNAMICALLY_CREATED) :
  IOutputStreamable<>      ()                               ,
  gForwardIdentifier       (true)                           ,
  gHasBeenDynamiclyCreated (gDYNAMICALLY_CREATED)           ,
  gIsDynamiclyLoadable     (false)                          ,
  gIsQualified             (false)                          ,
  gIsRootNode              (false)                          ,
  gIsVisible               (true)                           ,
  tAttributeMap            ()
{
  
  tAttributeMap.bind ("class",                "");
  tAttributeMap.bind ("class-identifier",     "tag");
  tAttributeMap.bind ("id",                   pkcIDENTIFIER);
  tAttributeMap.bind ("identifier",           pkcIDENTIFIER);
  tAttributeMap.bind ("qualified-identifier", pkcIDENTIFIER);
  tAttributeMap.bind ("value",                "");

}  // TTag()


mpcl::text::html::TTag::
~TTag (void)
{

  clear();

}  // TTag()


void mpcl::text::html::TTag::
setClass (const TString& rkyCLASS, bool)
{

  tAttributeMap ["class"] = rkyCLASS;

}  // setClass()


void mpcl::text::html::TTag::
setClass (const char* pkcCLASS, bool)
{

  tAttributeMap ["class"] = pkcCLASS;

}  // setClass()


//
//  S E L E C T O R S
//

mpcl::text::html::TTag::iterator mpcl::text::html::TTag::
begin (void)
{

  const char*   pkcFormat = "this class ('%s') doesn't support this function";
  TString       yMessage (Format (pkcFormat, identifier().c_str()));

  throw TConstraintException (yMessage, __FILE__, __LINE__);
  return iterator();

}  // begin()
      

mpcl::text::html::TTag::const_iterator mpcl::text::html::TTag::
begin (void) const
{

  const char*   pkcFormat = "this class ('%s') doesn't support this function";
  TString       yMessage (Format (pkcFormat, identifier().c_str()));

  throw TConstraintException (yMessage, __FILE__, __LINE__);
  return const_iterator();

}  // begin()
      

mpcl::text::TString mpcl::text::html::TTag::
code (const char* pkcINSTRUCTION, const char* pkcCLAUSE) const
{

  TString   yCode;

  if ( !_ptCodeGenerator )
  {
    throw TNoCodeGeneratorException ("no code generator", __FILE__, __LINE__);
  }
  else
  {
    yCode = (*_ptCodeGenerator) [pkcINSTRUCTION][pkcCLAUSE].instantiate();
  }
  return yCode;

}  // code()


mpcl::text::TString mpcl::text::html::TTag::
code ( const char*               pkcINSTRUCTION ,
       const char*               pkcCLAUSE      ,
       const TStringToStringMap& rktVALUE_MAP   ) const
{

  using codegen::TClauseBodyString;

  TString   yCode;

  if ( !_ptCodeGenerator )
  {
    throw TNoCodeGeneratorException ("no code generator", __FILE__, __LINE__);
  }
  else
  {
    TClauseBodyString   yClauseBody ((*_ptCodeGenerator) [pkcINSTRUCTION][pkcCLAUSE]);

    yClauseBody.setParameterExistenceSensitiveness (false);
    yCode = yClauseBody.instantiate (rktVALUE_MAP);
  }
  return yCode;

}  // code()


mpcl::text::html::TTag::iterator mpcl::text::html::TTag::
end (void)
{

  const char*   pkcFormat = "this class ('%s') doesn't support this function";
  TString       yMessage (Format (pkcFormat, identifier().c_str()));

  throw TConstraintException (yMessage, __FILE__, __LINE__);
  return iterator();

}  // end()


mpcl::text::html::TTag::const_iterator mpcl::text::html::TTag::
end (void) const
{

  const char*   pkcFormat = "this class ('%s') doesn't support this function";
  TString       yMessage (Format (pkcFormat, identifier().c_str()));

  throw TConstraintException (yMessage, __FILE__, __LINE__);
  return const_iterator();

}  // end()


void mpcl::text::html::TTag::
expand (TStringToStringMap& rtTARGET_VARIABLE_MAP) const
{

  TStringToStringMap::const_iterator   ktIter = tAttributeMap.begin();
  TStringToStringMap::const_iterator   ktEnd  = tAttributeMap.end();

  for (; ( ktIter != ktEnd ) ;++ktIter)
  {
    if ( ktIter->first == "align" )
    {
      rtTARGET_VARIABLE_MAP.bind ("align", code ("attribute.align", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "bgcolor" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("bgcolor", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("bgcolor", code ("attribute", "bgcolor", tAttributeMap));
      }
    }
    else if ( ktIter->first == "cgi-method" )
    {
      rtTARGET_VARIABLE_MAP.bind ("cgi-method", code ("attribute.cgi-method", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "checked" )
    {
      rtTARGET_VARIABLE_MAP.bind ("checked", code ("attribute.checked", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "class" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("class", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("class", code ("attribute", "class", tAttributeMap));
      }
    }
    else if ( ktIter->first == "colspan" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("colspan", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("colspan", code ("attribute", "colspan", tAttributeMap));
      }
    }
    else if ( ktIter->first == "halign" )
    {
      rtTARGET_VARIABLE_MAP.bind ("halign", code ("attribute.halign", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "height" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("height", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("height", code ("attribute", "height", tAttributeMap));
      }
    }
    else if ( ktIter->first == "href" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("href", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("href", code ("attribute", "href", tAttributeMap));
      }
    }
    else if ( ktIter->first == "id" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("id", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("id", code ("attribute", "id", tAttributeMap));
      }
    }
    else if ( ktIter->first == "ismap" )
    {
      rtTARGET_VARIABLE_MAP.bind ("ismap", code ("attribute.ismap", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "maxlength" )
    {
      if ( 0 < atoi (ktIter->second.c_str()) )
      {
        rtTARGET_VARIABLE_MAP.bind ("maxlength", code ("attribute", "maxlength", tAttributeMap));
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("maxlength", "");
      }
    }
    else if ( ktIter->first == "multiple" )
    {
      rtTARGET_VARIABLE_MAP.bind ("multiple", code ("attribute.multiple", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "noresize" )
    {
      rtTARGET_VARIABLE_MAP.bind ("noresize", code ("attribute.noresize", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "noshade" )
    {
      rtTARGET_VARIABLE_MAP.bind ("noshade", code ("attribute.noshade", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "nowrap" )
    {
      rtTARGET_VARIABLE_MAP.bind ("nowrap", code ("attribute.nowrap", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "rowspan" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("rowspan", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("rowspan", code ("attribute", "rowspan", tAttributeMap));
      }
    }
    else if ( ktIter->first == "selected" )
    {
      rtTARGET_VARIABLE_MAP.bind ("selected", code ("attribute.selected", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "size" )
    {
      if ( 0 < atoi (ktIter->second.c_str()) )
      {
        rtTARGET_VARIABLE_MAP.bind ("size", code ("attribute", "size", tAttributeMap));
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("size", "");
      }
    }
    else if ( ktIter->first == "target-named-anchor" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("target-named-anchor", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("target-named-anchor", TString ("#") + ktIter->second);
      }
    }
    else if ( ktIter->first == "valign" )
    {
      rtTARGET_VARIABLE_MAP.bind ("valign", code ("attribute.valign", ktIter->second.c_str()));
    }
    else if ( ktIter->first == "width" )
    {
      if ( ktIter->second.empty() )
      {
        rtTARGET_VARIABLE_MAP.bind ("width", "");
      }
      else
      {
        rtTARGET_VARIABLE_MAP.bind ("width", code ("attribute", "width", tAttributeMap));
      }
    }
    else
    {
      rtTARGET_VARIABLE_MAP.bind (ktIter->first, ktIter->second);
    }
  }

}  // expand()


const mpcl::text::html::TTag& mpcl::text::html::TTag::
operator [] (const char*) const
{
  
  const char*   pkcFormat = "this class ('%s') doesn't support this operator";
  TString       yMessage (Format (pkcFormat, identifier().c_str()));

  throw TConstraintException (yMessage, __FILE__, __LINE__);
  return *this;
  
}  // operator []()


mpcl::text::html::TTag& mpcl::text::html::TTag::
operator [] (const char*)
{
  
  const char*   pkcFormat = "this class ('%s') doesn't support this operator";
  TString       yMessage (Format (pkcFormat, identifier().c_str()));

  throw TConstraintException (yMessage, __FILE__, __LINE__);
  return *this;
  
}  // operator []()


mpcl::text::html::TTag::size_type mpcl::text::html::TTag::
size (void) const
{

  const char*   pkcFormat = "this class ('%s') doesn't support this function";
  TString       yMessage (Format (pkcFormat, identifier().c_str()));

  throw TConstraintException (yMessage, __FILE__, __LINE__);
  return 0;

}  // size()


mpcl::text::html::QTTag mpcl::text::html::TTag::
tag (const TString&) const
{

  const char*   pkcFormat = "this class ('%s') doesn't support this operator";
  TString       yMessage (Format (pkcFormat, identifier().c_str()));

  throw TConstraintException (yMessage, __FILE__, __LINE__);
  return QTTag();

}  // tag()


void mpcl::text::html::TTag::
writeUsing ( std::basic_ostream<char>&  rtTARGET_OSTREAM        ,
             const TString&             rkyQUALIFIED_IDENTIFIER ) const
{

  if ( isVisible() )
  {
    TStringToStringMap   tTargetValueMap;
    TString              yPathIdentifier = rkyQUALIFIED_IDENTIFIER;

    expand (tTargetValueMap);
    if ( gIsQualified && !qualifiedIdentifier().empty() )
    {
      if ( !yPathIdentifier.empty() )
      {
        yPathIdentifier += kcIdentifierSeparator;
      }
      yPathIdentifier += qualifiedIdentifier();
    }
    tTargetValueMap ["qualified-identifier"] = yPathIdentifier;
    rtTARGET_OSTREAM << code (tTargetValueMap ["class-identifier"].c_str(), "body", tTargetValueMap);
  }
  
}  // writeUsing()

---