//C-  -*- C++ -*-
//C- -------------------------------------------------------------------
//C- DjVuLibre-3.5
//C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
//C- Copyright (c) 2001  AT&T
//C-
//C- This software is subject to, and may be distributed under, the
//C- GNU General Public License, Version 2. The license should have
//C- accompanied the software or you may obtain a copy of the license
//C- from the Free Software Foundation at http://www.fsf.org .
//C-
//C- This program is distributed in the hope that it will be useful,
//C- but WITHOUT ANY WARRANTY; without even the implied warranty of
//C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//C- GNU General Public License for more details.
//C- 
//C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library
//C- distributed by Lizardtech Software.  On July 19th 2002, Lizardtech 
//C- Software authorized us to replace the original DjVu(r) Reference 
//C- Library notice by the following text (see doc/lizard2002.djvu):
//C-
//C-  ------------------------------------------------------------------
//C- | DjVu (r) Reference Library (v. 3.5)
//C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
//C- | The DjVu Reference Library is protected by U.S. Pat. No.
//C- | 6,058,214 and patents pending.
//C- |
//C- | This software is subject to, and may be distributed under, the
//C- | GNU General Public License, Version 2. The license should have
//C- | accompanied the software or you may obtain a copy of the license
//C- | from the Free Software Foundation at http://www.fsf.org .
//C- |
//C- | The computer code originally released by LizardTech under this
//C- | license and unmodified by other parties is deemed "the LIZARDTECH
//C- | ORIGINAL CODE."  Subject to any third party intellectual property
//C- | claims, LizardTech grants recipient a worldwide, royalty-free, 
//C- | non-exclusive license to make, use, sell, or otherwise dispose of 
//C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the 
//C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU 
//C- | General Public License.   This grant only confers the right to 
//C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to 
//C- | the extent such infringement is reasonably necessary to enable 
//C- | recipient to make, have made, practice, sell, or otherwise dispose 
//C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to 
//C- | any greater extent that may be necessary to utilize further 
//C- | modifications or combinations.
//C- |
//C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
//C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
//C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
//C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//C- +------------------------------------------------------------------
// 
// $Id: DjVuAnno.cpp,v 1.12 2004/04/17 23:56:11 leonb Exp $
// $Name: release_3_5_15 $

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#if NEED_GNUG_PRAGMAS
# pragma implementation
#endif

#include "DjVuAnno.h"
#include "GContainer.h"
#include "GException.h"
#include "IFFByteStream.h"
#include "BSByteStream.h"
#include "GMapAreas.h"

#include "debug.h"

#include <ctype.h>


#ifdef HAVE_NAMESPACES
namespace DJVU {
# ifdef NOT_DEFINED // Just to fool emacs c++ mode
}
#endif
#endif


// GLParser.h and GLParser.cpp used to be separate files capable to decode
// that weird ANTa chunk format into C++ structures and lists. But since
// its implementation is temporary and is used only in this file (DjVuAnno.cpp)
// it appears reasonable to build it in here.

//***************************************************************************
//****************************** GLParser.h *********************************
//***************************************************************************


class GLObject : public GPEnabled
{
public:
   enum GLObjectType { INVALID=0, NUMBER=1, STRING=2, SYMBOL=3, LIST=4 };
   static const char * const GLObjectString[LIST+1];

   GLObject(int _number=0);
   GLObject(GLObjectType type, const char * str);
   GLObject(const char * name, const GPList<GLObject> & list);
   virtual ~GLObject(void);
   
   int		get_number(void) const;
   GUTF8String	get_string(void) const;
   GUTF8String	get_symbol(void) const;
   GPList<GLObject>	& get_list(void);
   GP<GLObject>	operator[](int n) const;
   
   GLObjectType	get_type(void) const;
   GUTF8String	get_name(void) const;
   void		print(ByteStream & str, int compact=1, int indent=0, int * cur_pos=0) const;
private:
   GLObjectType	type;
   GUTF8String	name;
   
   int		number;
   GUTF8String	string;
   GUTF8String	symbol;
   GPList<GLObject>	list;
   void throw_can_not_convert_to(const GLObjectType to) const;
};

const char * const GLObject::GLObjectString[]=
  {"invalid", "number", "string", "symbol", "list"};

inline GLObject::GLObjectType
GLObject::get_type(void) const { return type; }

inline
GLObject::~GLObject(void) {}

class GLToken
{
public:
   enum GLTokenType { OPEN_PAR, CLOSE_PAR, OBJECT };
   GLTokenType	type;
   GP<GLObject>	object;
   
   GLToken(GLTokenType type, const GP<GLObject> & object);
};

inline
GLToken::GLToken(GLTokenType xtype, const GP<GLObject> & xobject) :
      type(xtype), object(xobject) {}

class GLParser
{
public:
   void		parse(const char * str);
   GPList<GLObject>	& get_list(void);
   GP<GLObject>		get_object(const char * name, bool last=true);
   void		print(ByteStream & str, int compact=1);

   GLParser(void);
   GLParser(const char * str);
   ~GLParser(void);
private:
   GPList<GLObject>	list;

   bool   	compat;
   void		skip_white_space(const char * & start);
   void 	check_compat(const char *str);
   GLToken	get_token(const char * & start);
   void		parse(const char * cur_name, GPList<GLObject> & list,
		      const char * & start);
};

GLParser::GLParser(void) 
  : compat(false)
{
}

GLParser::~GLParser(void) 
{
}

GPList<GLObject> &
GLParser::get_list(void) 
{ 
  return list; 
}

GLParser::GLParser(const char * str) 
  : compat(false)
{
  parse(str); 
}


//***************************************************************************
//***************************** GLParser.cpp ********************************
//***************************************************************************


GLObject::GLObject(int xnumber) : type(NUMBER), number(xnumber) {}

GLObject::GLObject(GLObjectType xtype, const char * str) : type(xtype)
{
   if (type!=STRING && type!=SYMBOL)
      G_THROW( ERR_MSG("DjVuAnno.bad_type") );
   if (type==STRING) 
      string=str;
   else symbol=str;
}

GLObject::GLObject(const char * xname, const GPList<GLObject> & xlist) :
      type(LIST), name(xname), list(xlist) {}

void
GLObject::print(ByteStream & str, int compact, int indent, int * cur_pos) const
{
  int local_cur_pos = 0;
  if (!cur_pos) { cur_pos = &local_cur_pos; }
  
  GUTF8String buffer;
  const char * to_print=0;
  switch(type)
  {
  case NUMBER:
    to_print=buffer.format("%d",number);
    break;
  case STRING:
    {
       int length = string.length();
       const char *data = (const char*)string;
       buffer = GUTF8String("\"");
       while (*data && length>0) 
         {
           int span = 0;
           while (span<length && (unsigned char)(data[span])>=0x20 && 
                  data[span]!=0x7f && data[span]!='"' && data[span]!='\\' )
             span++;
           if (span > 0) 
             {  
               buffer = buffer + GUTF8String(data, span);
               data += span;
               length -= span;
             }  
           else 
             {
               char buf[8];
               static char *tr1 = "\"\\tnrbf";
               static char *tr2 = "\"\\\t\n\r\b\f";
               sprintf(buf,"\\%03o", (int)(((unsigned char*)data)[span]));
               for (int i=0; tr2[i]; i++)
                 if (data[span] == tr2[i])
                   buf[1] = tr1[i];
               if (buf[1]<'0' || buf[1]>'3')
                 buf[2] = 0;
               buffer = buffer + GUTF8String(buf);
               data += 1;
               length -= 1;
             }
         }
       buffer = buffer + GUTF8String("\"");
       to_print = buffer;
    }
    break;
  case SYMBOL:
    to_print=buffer.format("%s",(const char *)symbol);
    break;
  case LIST:
    to_print=buffer.format("(%s",(const char *)name);
    break;
  case INVALID:
    break;
  }
  if (!compact && *cur_pos+strlen(to_print)>70)
  {
    char ch='\n';
    str.write(&ch, 1);
    ch=' ';
    for(int i=0;i<indent;i++) str.write(&ch, 1);
    *cur_pos=indent;
  }
  str.write(to_print, strlen(to_print));
  char ch=' ';
  str.write(&ch, 1);
  *cur_pos+=strlen(to_print)+1;
  if (type==LIST)
  {
    int indent=*cur_pos-strlen(to_print);
    for(GPosition pos=list;pos;++pos)
      list[pos]->print(str, compact, indent, cur_pos);
    str.write(") ", 2);
    *cur_pos+=2;
  }
}

//  This function constructs message names for external lookup.
//  The message names are constructed to avoid the problems of concatenating
//  phrases (which does not translate well into other languages). The
//  message names that can be generated are (listed here to appease the
//  auditing program which reads comments):
//    ERR_MSG("DjVuAnno.invalid2number"), ERR_MSG("DjVuAnno.string2number"),
//    ERR_MSG("DjVuAnno.symbol2number"), ERR_MSG("DjVuAnno.list2number")
//    ERR_MSG("DjVuAnno.invalid2string"), ERR_MSG("DjVuAnno.number2string"),
//    ERR_MSG("DjVuAnno.symbol2string"), ERR_MSG("DjVuAnno.list2string")
//    ERR_MSG("DjVuAnno.invalid2symbol"), ERR_MSG("DjVuAnno.number2symbol"),
//    ERR_MSG("DjVuAnno.string2symbol"), ERR_MSG("DjVuAnno.list2symbol")
//    ERR_MSG("DjVuAnno.invalid2list"), ERR_MSG("DjVuAnno.number2list"),
//    ERR_MSG("DjVuAnno.string2list"), ERR_MSG("DjVuAnno.symbol2list")
void
GLObject::throw_can_not_convert_to(const GLObjectType to) const
{
  static const GUTF8String two('2');
  static const GUTF8String tab('\t');
  GUTF8String mesg("DjVuAnno.");
  switch(type)
  {
    case NUMBER:
      mesg+=GLObjectString[NUMBER]+two+GLObjectString[to]+tab+GUTF8String(number);
      break;
    case STRING:
      mesg+=GLObjectString[STRING]+two+GLObjectString[to]+tab+string;
      break;
    case SYMBOL:
      mesg+=GLObjectString[SYMBOL]+two+GLObjectString[to]+tab+symbol;
      break;
    case LIST:
      mesg+=GLObjectString[LIST]+two+GLObjectString[to]+tab+name;
      break;
    default:
      mesg+=GLObjectString[INVALID]+two+GLObjectString[to];
      break;
  }
  G_THROW(mesg);
}

GUTF8String
GLObject::get_string(void) const
{
   if (type!=STRING)
   {
      throw_can_not_convert_to(STRING);
   }
   return string;
}

GUTF8String
GLObject::get_symbol(void) const
{
   if (type!=SYMBOL)
   {
      throw_can_not_convert_to(SYMBOL);
   }
   return symbol;
}

int
GLObject::get_number(void) const
{
   if (type!=NUMBER)
   {
      throw_can_not_convert_to(NUMBER);
   }
   return number;
}

GUTF8String
GLObject::get_name(void) const
{
   if (type!=LIST)
   {
      throw_can_not_convert_to(LIST);
   }
   return name;
}

GP<GLObject>
GLObject::operator[](int n) const
{
   if (type!=LIST)
   {
      throw_can_not_convert_to(LIST);
   }
   if (n>=list.size()) G_THROW( ERR_MSG("DjVuAnno.too_few") "\t"+name);
   int i;
   GPosition pos;
   for(i=0, pos=list;i<n && pos;i++, ++pos)
   		continue;
   return list[pos];
}

GPList<GLObject> &
GLObject::get_list(void)
{
   if (type!=LIST)
   {
      throw_can_not_convert_to(LIST);
   }
   return list;
}

//********************************** GLParser *********************************

void
GLParser::skip_white_space(const char * & start)
{
   while(*start && isspace(*start)) start++;
   if (!*start) 
       G_THROW( ByteStream::EndOfFile );
}

GLToken
GLParser::get_token(const char * & start)
{
   skip_white_space(start);
   char c = *start;
   if (c == '(')
     {
       start++;
       return GLToken(GLToken::OPEN_PAR, 0);
     }
   else if (c == ')')
     {
       start++;
       return GLToken(GLToken::CLOSE_PAR, 0);
     }
   else if (c=='-' || (c>='0' && c<='9'))
     {
       return GLToken(GLToken::OBJECT,
                      new GLObject(strtol(start, (char **) &start, 10)));
     }
   else if (c=='"')
     {
       GUTF8String str;
       start++;
       while(1)
	 {
           int span = 0;
           while (start[span] && start[span]!='\\' && start[span]!='\"')
             span++;
           if (span > 0)
             {
               str = str + GUTF8String(start,span);
               start += span;
             }
           else if (start[0]=='\"')
             {
               start += 1;
               break;
             }
           else if (start[0]=='\\' && compat)
             {
               char c = start[1];
               if (c == '\"')
                 {
                   start += 2;
                   str += '\"';
                 }
               else
                 {
                   start += 1;
                   str += '\\';
                 }
             }
           else if (start[0]=='\\' && start[1])
             {
               char c = *++start;
               if (c>='0' && c<='7')
                 {
                   int x = 0;
                   for (int i=0; i<3 && c>='0' && c<='7'; i++) 
                     {
                       x = x * 8 + c - '0';
                       c = *++start;
                     }
                   str += (char)(x & 0xff);
                 }
               else
                 {
                   static char *tr1 = "tnrbfva";
                   static char *tr2 = "\t\n\r\b\f\013\007";
                   for (int i=0; tr1[i]; i++)
                     if (c == tr1[i])
                       c = tr2[i];
                   start += 1;
                   str += c;
                 }
             }
           else 
             {
               G_THROW( ByteStream::EndOfFile );
             }
         }
       return GLToken(GLToken::OBJECT, 
                      new GLObject(GLObject::STRING, str));
     }
   else
     {
       GUTF8String str;
       while(1)
	 {
           char ch=*start++;
           if (!ch)
             G_THROW( ByteStream::EndOfFile );
           if (ch==')') { start--; break; }
           if (isspace(ch)) break;
           str+=ch;
	 }
       return GLToken(GLToken::OBJECT, new GLObject(GLObject::SYMBOL, str));
     }
} 

void
GLParser::parse(const char * cur_name, GPList<GLObject> & list,
		const char * & start)
{
  DEBUG_MSG("GLParse::parse(): Parsing contents of object '" << cur_name << "'\n");
  DEBUG_MAKE_INDENT(3);
  
  while(1)
  {
    GLToken token=get_token(start);
    if (token.type==GLToken::OPEN_PAR)
    {
      if (isspace(*start))
      {
        GUTF8String mesg=GUTF8String( ERR_MSG("DjVuAnno.paren") "\t")+cur_name;
        G_THROW(mesg);
      }
      
      GLToken tok=get_token(start);
      GP<GLObject> object=tok.object;	// This object should be SYMBOL
      // We will convert it to LIST later
      if (tok.type!=GLToken::OBJECT || object->get_type()!=GLObject::SYMBOL)
      {
        if (tok.type==GLToken::OPEN_PAR ||
          tok.type==GLToken::CLOSE_PAR)
        {
          GUTF8String mesg=GUTF8String( ERR_MSG("DjVuAnno.no_paren") "\t")+cur_name;
          G_THROW(mesg);
        }
        if (tok.type==GLToken::OBJECT)
        {
          GLObject::GLObjectType type=object->get_type();
          if (type==GLObject::NUMBER)
          {
            GUTF8String mesg( ERR_MSG("DjVuAnno.no_number") "\t");
            mesg += cur_name;
            G_THROW(mesg);
          }
          else if (type==GLObject::STRING)
          {
            GUTF8String mesg( ERR_MSG("DjVuAnno.no_string") "\t");
            mesg += cur_name;
            G_THROW(mesg);
          }
        }
      }
      
      // OK. Get the object contents
      GPList<GLObject> new_list;
      G_TRY
      {
        parse(object->get_symbol(), new_list, start);
      } 
      G_CATCH(exc)
      {
        if (exc.cmp_cause(ByteStream::EndOfFile))
          G_RETHROW;
      } 
      G_ENDCATCH;
      list.append(new GLObject(object->get_symbol(), new_list));
      continue;
    }
    if (token.type==GLToken::CLOSE_PAR) 
      return;
    list.append(token.object);
  }
}

void 
GLParser::check_compat(const char *s)
{
  int state = 0;
  while (s && *s && !compat)
    {
      switch(state)
        {
        case 0:
          if (*s == '\"')
            state = '\"';
          break;
        case '\"':
          if (*s == '\"')
            state = 0;
          else if (*s == '\\')
            state = '\\';
          else if ((unsigned char)(*s)<0x20 || *s==0x7f)
            compat = true;
          break;
        case '\\':
          if (!strchr("01234567tnrbfva\"\\",*s))
            compat = true;
          state = '\"';
          break;
        }
      s += 1;
    }
}

void
GLParser::parse(const char * str)
{
   DEBUG_MSG("GLParser::parse(): parsing string contents\n");
   DEBUG_MAKE_INDENT(3);
   
   G_TRY
   {
      check_compat(str);
      parse("toplevel", list, str);
   } G_CATCH(exc)
   {
      if (exc.cmp_cause(ByteStream::EndOfFile))
        G_RETHROW;
   } G_ENDCATCH;
}

void
GLParser::print(ByteStream & str, int compact)
{
   for(GPosition pos=list;pos;++pos)
      list[pos]->print(str, compact);
}

GP<GLObject>
GLParser::get_object(const char * name, bool last)
{
   GP<GLObject> object;
   for(GPosition pos=list;pos;++pos)
   {
      GP<GLObject> obj=list[pos];
      if (obj->get_type()==GLObject::LIST &&
	  obj->get_name()==name)
      {
	 object=obj;
	 if (!last) break;
      }
   }
   return object;
}

//***************************************************************************
//********************************** ANT ************************************
//***************************************************************************

static const char *zoom_strings[]={
  "default","page","width","one2one","stretch"};
static const int zoom_strings_size=sizeof(zoom_strings)/sizeof(const char *);

static const char *mode_strings[]={
  "default","color","fore","back","bw"};
static const int mode_strings_size=sizeof(mode_strings)/sizeof(const char *);

static const char *align_strings[]={
  "default","left","center","right","top","bottom"};
static const int align_strings_size=sizeof(align_strings)/sizeof(const char *);

#define PNOTE_TAG	"pnote"
#define BACKGROUND_TAG	"background"
#define ZOOM_TAG	"zoom"
#define MODE_TAG	"mode"
#define ALIGN_TAG	"align"
#define HALIGN_TAG	"halign"
#define VALIGN_TAG	"valign"
#define METADATA_TAG    "metadata"

static const unsigned long default_bg_color=0xffffffff;

DjVuANT::DjVuANT(void)
{
   bg_color=default_bg_color;
   zoom=0;
   mode=MODE_UNSPEC;
   hor_align=ver_align=ALIGN_UNSPEC;
}

DjVuANT::~DjVuANT()
{
}

GUTF8String
DjVuANT::get_paramtags(void) const
{
  GUTF8String retval;
  if(zoom > 0)
  {
    retval+="<PARAM name=\"" ZOOM_TAG "\" value=\""+GUTF8String(zoom)+="\" />\n";
  }else if(zoom && ((-zoom)<zoom_strings_size))
  {
    retval+="<PARAM name=\"" ZOOM_TAG "\" value=\""+GUTF8String(zoom_strings[-zoom])+"\" />\n";
  }
  if((mode>0)&&(mode<mode_strings_size))
  {
    retval+="<PARAM name=\"" MODE_TAG "\" value=\""+GUTF8String(mode_strings[mode])+"\" />\n";
  }
  if((hor_align>ALIGN_UNSPEC)&&(hor_align<align_strings_size))
  {
    retval+="<PARAM name=\"" HALIGN_TAG "\" value=\""+GUTF8String(align_strings[hor_align])+"\" />\n";
  }
  if((ver_align>ALIGN_UNSPEC)&&(ver_align<align_strings_size))
  {
    retval+="<PARAM name=\"" VALIGN_TAG "\" value=\""+GUTF8String(align_strings[ver_align])+"\" />\n";
  }
  if((bg_color&0xffffff) == bg_color)
  {
    retval+="<PARAM name=\"" BACKGROUND_TAG "\" value=\""+GUTF8String().format("#%06lX",bg_color)+"\" />\n";
  }
  return retval;
}

void
DjVuANT::writeParam(ByteStream &str_out) const
{
  str_out.writestring(get_paramtags());
}

GUTF8String
DjVuANT::get_xmlmap(const GUTF8String &name,const int height) const
{
  GUTF8String retval("<MAP name=\""+name.toEscaped()+"\" >\n");
  for(GPosition pos(map_areas);pos;++pos)
  {
    retval+=map_areas[pos]->get_xmltag(height);
  }
  return retval+"</MAP>\n";
}

void
DjVuANT::writeMap(
  ByteStream &str_out,const GUTF8String &name,const int height) const
{
  str_out.writestring("<MAP name=\""+name.toEscaped()+"\" >\n");
  for(GPosition pos(map_areas);pos;++pos)
  {
    str_out.writestring(GUTF8String(map_areas[pos]->get_xmltag(height)));
  }
  str_out.writestring(GUTF8String("</MAP>\n"));
}

GUTF8String
DjVuANT::read_raw(ByteStream & str)
{
   GUTF8String raw;
   char buffer[1024];
   int length;
   while((length=str.read(buffer, 1024)))
      raw+=GUTF8String(buffer, length);
   return raw;
}

void
DjVuANT::decode(class GLParser & parser)
{
   bg_color=get_bg_color(parser);
   zoom=get_zoom(parser);
   mode=get_mode(parser);
   hor_align=get_hor_align(parser);
   ver_align=get_ver_align(parser);
   map_areas=get_map_areas(parser);
#ifndef NO_METADATA_IN_ANT_CHUNK
   metadata=get_metadata(parser); 
#endif
}


void 
DjVuANT::decode(ByteStream & str)
{
   GLParser parser(read_raw(str));
   decode(parser);
}

void
DjVuANT::merge(ByteStream & str)
{
   GLParser parser(encode_raw());
   GUTF8String add_raw=read_raw(str);
   parser.parse(add_raw);
   decode(parser);
}

void
DjVuANT::encode(ByteStream &bs)
{
  GUTF8String raw=encode_raw();
  bs.writall((const char*) raw, raw.length());
}

unsigned int 
DjVuANT::get_memory_usage() const
{
  return sizeof(DjVuANT);
}

unsigned char
DjVuANT::decode_comp(char ch1, char ch2)
{
   unsigned char dig1=0;
   if (ch1)
   {
      ch1=toupper(ch1);
      if (ch1>='0' && ch1<='9') dig1=ch1-'0';
      if (ch1>='A' && ch1<='F') dig1=10+ch1-'A';
      
      unsigned char dig2=0;
      if (ch2)
      {
	 ch2=toupper(ch2);
	 if (ch2>='0' && ch2<='9') dig2=ch2-'0';
	 if (ch2>='A' && ch2<='F') dig2=10+ch2-'A';
	 return (dig1 << 4) | dig2;
      }
      return dig1;
   }
   return 0;
}

unsigned long int
DjVuANT::cvt_color(const char * color, unsigned long int def)
{
   if (color[0]!='#') return def;

   unsigned long int color_rgb=0;
   color++;
   const char * start, * end;
   
      // Do blue
   end=color+strlen(color); start=end-2;
   if (start<color) start=color;
   if (end>start)
      color_rgb|=decode_comp(start[0], start+1<end ? start[1] : 0);
   
      // Do green
   end=color+strlen(color)-2; start=end-2;
   if (start<color) start=color;
   if (end>start)
      color_rgb|=decode_comp(start[0], start+1<end ? start[1] : 0) << 8;
   
      // Do red
   end=color+strlen(color)-4; start=end-2;
   if (start<color) start=color;
   if (end>start)
      color_rgb|=decode_comp(start[0], start+1<end ? start[1] : 0) << 16;

      // Do the fourth byte
   end=color+strlen(color)-6; start=end-2;
   if (start<color) start=color;
   if (end>start)
      color_rgb|=decode_comp(start[0], start+1<end ? start[1] : 0) << 24;
   
   return color_rgb;
}

unsigned long int
DjVuANT::get_bg_color(GLParser & parser)
{
  unsigned long retval=default_bg_color;
  DEBUG_MSG("DjVuANT::get_bg_color(): getting background color ...\n");
  DEBUG_MAKE_INDENT(3);
  G_TRY
  {
    GP<GLObject> obj=parser.get_object(BACKGROUND_TAG);
    if (obj && obj->get_list().size()==1)
    {
      GUTF8String color=(*obj)[0]->get_symbol();
      DEBUG_MSG("color='" << color << "'\n");
      retval=cvt_color(color, 0xffffff);
    }
#ifndef NDEBUG
    if(retval == default_bg_color)
    {
      DEBUG_MSG("can't find any.\n");
    }
#endif // NDEBUG
  } G_CATCH_ALL {} G_ENDCATCH;
#ifndef NDEBUG
  if(retval == default_bg_color)
  {
    DEBUG_MSG("resetting color to 0xffffffff (UNSPEC)\n");
  }
#endif // NDEBUG
  return retval;
}

int
DjVuANT::get_zoom(GLParser & parser)
      // Returns:
      //   <0 - special zoom (like ZOOM_STRETCH)
      //   =0 - not set
      //   >0 - numeric zoom (%%)
{
  int retval=ZOOM_UNSPEC;
  DEBUG_MSG("DjVuANT::get_zoom(): getting zoom factor ...\n");
  DEBUG_MAKE_INDENT(3);
  G_TRY
  {
    GP<GLObject> obj=parser.get_object(ZOOM_TAG);
    if (obj && obj->get_list().size()==1)
    {
      const GUTF8String zoom((*obj)[0]->get_symbol());
      DEBUG_MSG("zoom='" << zoom << "'\n");
     
      for(int i=0;(i<zoom_strings_size);++i)
      {
        if(zoom == zoom_strings[i])
        {
          retval=(-i);
          break;
        }
      }
      if(retval == ZOOM_UNSPEC)
      {
        if (zoom[0]!='d')
        {
          G_THROW( ERR_MSG("DjVuAnno.bad_zoom") );
        }else
        {
          retval=zoom.substr(1, zoom.length()).toInt(); //atoi((const char *) zoom+1);
        }
      }
    }
#ifndef NDEBUG
    if(retval == ZOOM_UNSPEC)
    {
      DEBUG_MSG("can't find any.\n");
    }
#endif // NDEBUG
  } G_CATCH_ALL {} G_ENDCATCH;
#ifndef NDEBUG
  if(retval == ZOOM_UNSPEC)
  {
    DEBUG_MSG("resetting zoom to 0 (UNSPEC)\n");
  }
#endif // NDEBUG
  return retval;
}

int
DjVuANT::get_mode(GLParser & parser)
{
  int retval=MODE_UNSPEC;
  DEBUG_MSG("DjVuAnt::get_mode(): getting default mode ...\n");
  DEBUG_MAKE_INDENT(3);
  G_TRY
  {
    GP<GLObject> obj=parser.get_object(MODE_TAG);
    if (obj && obj->get_list().size()==1)
    {
      const GUTF8String mode((*obj)[0]->get_symbol());
      DEBUG_MSG("mode='" << mode << "'\n");
      for(int i=0;(i<mode_strings_size);++i)
      {
        if(mode == mode_strings[i])
        {
          retval=i;
          break;
        }
      }
    }
#ifndef NDEBUG
    if(retval == MODE_UNSPEC)
    {
      DEBUG_MSG("can't find any.\n");
    }
#endif // NDEBUG
  } G_CATCH_ALL {} G_ENDCATCH;
#ifndef NDEBUG
  if(retval == MODE_UNSPEC)
  {
    DEBUG_MSG("resetting mode to MODE_UNSPEC\n");
  }
#endif // NDEBUG
  return retval;
}

static inline DjVuANT::alignment
legal_halign(const int i)
{
  DjVuANT::alignment retval;
  switch((DjVuANT::alignment)i)
  {
  case DjVuANT::ALIGN_LEFT:
  case DjVuANT::ALIGN_CENTER:
  case DjVuANT::ALIGN_RIGHT:
    retval=(DjVuANT::alignment)i;
    break;
  default:
    retval=DjVuANT::ALIGN_UNSPEC;
    break;
  }
  return retval;
}

static inline DjVuANT::alignment
legal_valign(const int i)
{
  DjVuANT::alignment retval;
  switch((DjVuANT::alignment)i)
  {
  case DjVuANT::ALIGN_CENTER:
  case DjVuANT::ALIGN_TOP:
  case DjVuANT::ALIGN_BOTTOM:
    retval=(DjVuANT::alignment)i;
    break;
  default:
    retval=DjVuANT::ALIGN_UNSPEC;
    break;
  }
  return retval;
}

DjVuANT::alignment
DjVuANT::get_hor_align(GLParser & parser)
{
  DEBUG_MSG("DjVuAnt::get_hor_align(): getting hor page alignemnt ...\n");
  DEBUG_MAKE_INDENT(3);
  alignment retval=ALIGN_UNSPEC;
  G_TRY
  {
    GP<GLObject> obj=parser.get_object(ALIGN_TAG);
    if (obj && obj->get_list().size()==2)
    {
      const GUTF8String align((*obj)[0]->get_symbol());
      DEBUG_MSG("hor_align='" << align << "'\n");
      
      for(int i=(int)ALIGN_UNSPEC;(i<align_strings_size);++i)
      {
        const alignment j=legal_halign(i);
        if((i == (int)j)&&(align == align_strings[i]))
        {
          retval=j;
          break;
        }
      }
    }
#ifndef NDEBUG
    if(retval == ALIGN_UNSPEC)
    {
      DEBUG_MSG("can't find any.\n");
    }
#endif // NDEBUG
  } G_CATCH_ALL {} G_ENDCATCH;
#ifndef NDEBUG
  if(retval == ALIGN_UNSPEC)
  {
    DEBUG_MSG("resetting alignment to ALIGN_UNSPEC\n");
  }
#endif // NDEBUG
  return retval;
}

DjVuANT::alignment
DjVuANT::get_ver_align(GLParser & parser)
{
  DEBUG_MSG("DjVuAnt::get_ver_align(): getting vert page alignemnt ...\n");
  DEBUG_MAKE_INDENT(3);
  alignment retval=ALIGN_UNSPEC;
  G_TRY
  {
    GP<GLObject> obj=parser.get_object(ALIGN_TAG);
    if (obj && obj->get_list().size()==2)
    {
      const GUTF8String align((*obj)[1]->get_symbol());
      DEBUG_MSG("ver_align='" << align << "'\n");
      for(int i=(int)ALIGN_UNSPEC;(i<align_strings_size);++i)
      {
        const alignment j=legal_valign(i);
        if((i == (int)j)&&(align == align_strings[i]))
        {
          retval=j;
          break;
        }
      }
    }
#ifndef NDEBUG
    if(retval == ALIGN_UNSPEC)
    {
      DEBUG_MSG("can't find any.\n");
    }
#endif // NDEBUG
  } G_CATCH_ALL {} G_ENDCATCH;
#ifndef NDEBUG
  if(retval == ALIGN_UNSPEC)
  {
    DEBUG_MSG("resetting alignment to ALIGN_UNSPEC\n");
  }
#endif // NDEBUG
  return retval;
}

#ifndef NO_METADATA_IN_ANT_CHUNK
GMap<GUTF8String, GUTF8String>
DjVuANT::get_metadata(GLParser & parser)
{
  DEBUG_MSG("DjVuANT::get_map_areas(): forming and returning back list of map areas\n");
  DEBUG_MAKE_INDENT(3);
  
  GMap<GUTF8String, GUTF8String> mdata;
  
  GPList<GLObject> list=parser.get_list();
  for(GPosition pos=list;pos;++pos)
    {
      GLObject & obj=*list[pos];
      if (obj.get_type()==GLObject::LIST && obj.get_name()==METADATA_TAG)  
        { 
          G_TRY 
            {
              for(int obj_num=0;obj_num<obj.get_list().size();obj_num++)
                {
                  GLObject & el=*obj[obj_num];
                  const int type = el.get_type();
                  if (type == GLObject::LIST)
                    { 
                      const GUTF8String & name=el.get_name();  
                      mdata[name]=(el[0])->get_string();
                    }
                }
            } 
          G_CATCH_ALL { } G_ENDCATCH;
        }
    }
  return mdata;
}
#endif

GPList<GMapArea>
DjVuANT::get_map_areas(GLParser & parser)
{
  DEBUG_MSG("DjVuANT::get_map_areas(): forming and returning back list of map areas\n");
  DEBUG_MAKE_INDENT(3);
  
  GPList<GMapArea> map_areas;
  
  GPList<GLObject> list=parser.get_list();

  for(GPosition pos=list;pos;++pos)
  {
    GLObject & obj=*list[pos];
    const int type=obj.get_type();
    if (type == GLObject::LIST)
    {
      const GUTF8String name=obj.get_name();
      if(name == GMapArea::MAPAREA_TAG)
      {
        G_TRY {
	       // Getting the url
          GUTF8String url;
          GUTF8String target=GMapArea::TARGET_SELF;
          GLObject & url_obj=*(obj[0]);
          if (url_obj.get_type()==GLObject::LIST)
          {
            if (url_obj.get_name()!=GMapArea::URL_TAG)
              G_THROW( ERR_MSG("DjVuAnno.bad_url") );
            url=(url_obj[0])->get_string();
            target=(url_obj[1])->get_string();
          } else url=url_obj.get_string();
        
	       // Getting the comment
          GUTF8String comment=(obj[1])->get_string();
        
          DEBUG_MSG("found maparea '" << comment << "' (" <<
            url << ":" << target << ")\n");
        
          GLObject * shape=obj[2];
          GP<GMapArea> map_area;
          if (shape->get_type()==GLObject::LIST)
          {
            if (shape->get_name()==GMapArea::RECT_TAG)
            {
              DEBUG_MSG("it's a rectangle.\n");
              GRect grect((*shape)[0]->get_number(),
                          (*shape)[1]->get_number(),
                          (*shape)[2]->get_number(),
                          (*shape)[3]->get_number());
              GP<GMapRect> map_rect=GMapRect::create(grect);
              map_area=(GMapRect *)map_rect;
            } else if (shape->get_name()==GMapArea::POLY_TAG)
            {
              DEBUG_MSG("it's a polygon.\n");
              int points=shape->get_list().size()/2;
              GTArray<int> xx(points-1), yy(points-1);
              for(int i=0;i<points;i++)
              {
                xx[i]=(*shape)[2*i]->get_number();
                yy[i]=(*shape)[2*i+1]->get_number();
              }
              GP<GMapPoly> map_poly=GMapPoly::create(xx,yy,points);
              map_area=(GMapPoly *)map_poly;
            } else if (shape->get_name()==GMapArea::OVAL_TAG)
            {
              DEBUG_MSG("it's an ellipse.\n");
              GRect grect((*shape)[0]->get_number(),
                          (*shape)[1]->get_number(),
                          (*shape)[2]->get_number(),
                          (*shape)[3]->get_number());
              GP<GMapOval> map_oval=GMapOval::create(grect);
              map_area=(GMapOval *)map_oval;
            }
          }
        
          if (map_area)
          {
            map_area->url=url;
            map_area->target=target;
            map_area->comment=comment;
            for(int obj_num=3;obj_num<obj.get_list().size();obj_num++)
            {
              GLObject * el=obj[obj_num];
              if (el->get_type()==GLObject::LIST)
              {
                const GUTF8String & name=el->get_name();
                if (name==GMapArea::BORDER_AVIS_TAG)
                  map_area->border_always_visible=true;
                else if (name==GMapArea::HILITE_TAG)
                {
                  GLObject * obj=el->get_list()[el->get_list().firstpos()];
                  if (obj->get_type()==GLObject::SYMBOL)
                    map_area->hilite_color=cvt_color(obj->get_symbol(), 0xff);
                } else
                {
                  int border_type=
                    name==GMapArea::NO_BORDER_TAG ? GMapArea::NO_BORDER :
                    name==GMapArea::XOR_BORDER_TAG ? GMapArea::XOR_BORDER :
                    name==GMapArea::SOLID_BORDER_TAG ? GMapArea::SOLID_BORDER :
                    name==GMapArea::SHADOW_IN_BORDER_TAG ? GMapArea::SHADOW_IN_BORDER :
                    name==GMapArea::SHADOW_OUT_BORDER_TAG ? GMapArea::SHADOW_OUT_BORDER :
                    name==GMapArea::SHADOW_EIN_BORDER_TAG ? GMapArea::SHADOW_EIN_BORDER :
                    name==GMapArea::SHADOW_EOUT_BORDER_TAG ? GMapArea::SHADOW_EOUT_BORDER : -1;
                  if (border_type>=0)
                  {
                    map_area->border_type=(GMapArea::BorderType) border_type;
                    for(GPosition pos=el->get_list();pos;++pos)
                    {
                      GLObject * obj=el->get_list()[pos];
                      if (obj->get_type()==GLObject::SYMBOL)
                        map_area->border_color=cvt_color(obj->get_symbol(), 0xff);
                      if (obj->get_type()==GLObject::NUMBER)
                        map_area->border_width=obj->get_number();
                    }
                  }
                }	    
              } // if (el->get_type()==...)
            } // for(int obj_num=...)
            map_areas.append(map_area);
          } // if (map_area) ...
        } G_CATCH_ALL {} G_ENDCATCH;
      }
    }
  } // while(item==...)
   
  DEBUG_MSG("map area list size = " << list.size() << "\n");
  
  return map_areas;
}

void
DjVuANT::del_all_items(const char * name, GLParser & parser)
{
   GPList<GLObject> & list=parser.get_list();
   GPosition pos=list;
   while(pos)
   {
      GLObject & obj=*list[pos];
      if (obj.get_type()==GLObject::LIST &&
	  obj.get_name()==name)
      {
	 GPosition this_pos=pos;
	 ++pos;
	 list.del(this_pos);
      } else ++pos;
   }
}

GUTF8String
DjVuANT::encode_raw(void) const
{
   GUTF8String buffer;
   GLParser parser;

      //*** Background color
   del_all_items(BACKGROUND_TAG, parser);
   if (bg_color!=default_bg_color)
   {
      buffer.format("(" BACKGROUND_TAG " #%02X%02X%02X)",
	      (unsigned int)((bg_color & 0xff0000) >> 16),
	      (unsigned int)((bg_color & 0xff00) >> 8),
	      (unsigned int)(bg_color & 0xff));
      parser.parse(buffer);
   }

      //*** Zoom
   del_all_items(ZOOM_TAG, parser);
   if (zoom!=ZOOM_UNSPEC)
   {
      buffer="(" ZOOM_TAG " ";
      const int i=1-zoom;
      if((i>=0)&& (i<zoom_strings_size))
      {
        buffer+=zoom_strings[i];
      }else
      {
        buffer+="d"+GUTF8String(zoom);
      }
      buffer+=")";
      parser.parse(buffer);
   }

      //*** Mode
   del_all_items(MODE_TAG, parser);
   if (mode!=MODE_UNSPEC)
   {
      const int i=mode-1;
      if((i>=0)&& (i<mode_strings_size))
      { 
        buffer="(" MODE_TAG " " + GUTF8String(mode_strings[mode]) + ")";
      }
      parser.parse(buffer);
   }

      //*** Alignment
   del_all_items(ALIGN_TAG, parser);
   if (hor_align!=ALIGN_UNSPEC || ver_align!=ALIGN_UNSPEC)
   {
      buffer= GUTF8String("(" ALIGN_TAG " ")
        +align_strings[((hor_align<ALIGN_UNSPEC)||
                        (hor_align>=align_strings_size))?ALIGN_UNSPEC:hor_align]
        +" "+align_strings[((ver_align<ALIGN_UNSPEC)||
                            (ver_align>=align_strings_size))?ALIGN_UNSPEC:ver_align]+")";
      parser.parse(buffer);
   }
      //*** Metadata
#ifndef NO_METADATA_IN_ANT_CHUNK
   del_all_items(METADATA_TAG, parser);
   if (!metadata.isempty())
     {
       GUTF8String mdatabuffer("(");
       mdatabuffer +=  METADATA_TAG ;
       for (GPosition pos=metadata; pos; ++pos)
         mdatabuffer +=" (" + metadata.key(pos)+" \""+metadata[pos]+"\")";
       mdatabuffer += " )";
       parser.parse(mdatabuffer);
     }
#endif   
     //*** Mapareas
   del_all_items(GMapArea::MAPAREA_TAG, parser);
   for(GPosition pos=map_areas;pos;++pos)
      parser.parse(map_areas[pos]->print());

   GP<ByteStream> gstr=ByteStream::create();
   ByteStream &str=*gstr;
   parser.print(str, 1);
   GUTF8String ans;
   int size = str.size();
   str.seek(0);
   str.read(ans.getbuf(size), size);
   return ans;
}

bool
DjVuANT::is_empty(void) const
{
   GUTF8String raw=encode_raw();
   for(int i=raw.length()-1;i>=0;i--)
      if (isspace(raw[i])) raw.setat(i, 0);
      else break;
   return raw.length()==0;
}

GP<DjVuANT>
DjVuANT::copy(void) const
{
   GP<DjVuANT> ant=new DjVuANT(*this);


      // Now process the list of hyperlinks.
   ant->map_areas.empty();
   for(GPosition pos=map_areas;pos;++pos)
      ant->map_areas.append(map_areas[pos]->get_copy());

   return ant;
}

//***************************************************************************
//******************************** DjVuAnno *********************************
//***************************************************************************

GUTF8String
DjVuAnno::get_xmlmap(const GUTF8String &name,const int height) const
{
  return ant
    ?(ant->get_xmlmap(name,height))
    :("<MAP name=\""+name.toEscaped()+"\"/>\n");
}

void
DjVuAnno::writeMap(ByteStream &str_out,const GUTF8String &name,const int height) const
{
  if(ant)
  {
    ant->writeMap(str_out,name,height);
  }else
  {
    str_out.writestring(get_xmlmap(name,height));
  }
}

GUTF8String
DjVuAnno::get_paramtags(void) const
{
  return ant
    ?(ant->get_paramtags())
    :GUTF8String();
}

void
DjVuAnno::writeParam(ByteStream &str_out) const
{
  str_out.writestring(get_paramtags());
}


void
DjVuAnno::decode(const GP<ByteStream> &gbs)
{
  GUTF8String chkid;
  GP<IFFByteStream> giff=IFFByteStream::create(gbs);
  IFFByteStream &iff=*giff;
  while( iff.get_chunk(chkid) )
  {
    if (chkid == "ANTa")
    {
      if (ant) {
        ant->merge(*iff.get_bytestream());
      } else {
        ant=DjVuANT::create();
        ant->decode(*iff.get_bytestream());
      }
    }
    else if (chkid == "ANTz")
    {
      GP<ByteStream> gbsiff=BSByteStream::create(giff->get_bytestream());
      if (ant) {
        ant->merge(*gbsiff);
      } else {
        ant=DjVuANT::create();
        ant->decode(*gbsiff);
      }
    }
    // Add decoding of other chunks here
    iff.close_chunk();
  }
}

void
DjVuAnno::encode(const GP<ByteStream> &gbs)
{
  GP<IFFByteStream> giff=IFFByteStream::create(gbs);
  IFFByteStream &iff=*giff;
  if (ant)
    {
#if 0
      iff.put_chunk("ANTa");
      ant->encode(iff);
      iff.close_chunk();
#else
      iff.put_chunk("ANTz");
      {
//	 GP<ByteStream> bsbinput = giff.get_bytestream();
	 GP<ByteStream> bsb = BSByteStream::create(giff->get_bytestream(), 50);
	 ant->encode(*bsb);
      }
      iff.close_chunk();
#endif
    }
  // Add encoding of other chunks here
}


GP<DjVuAnno>
DjVuAnno::copy(void) const
{
   GP<DjVuAnno> anno= new DjVuAnno;
      // Copy any primitives (if any)
   *anno=*this;
      // Copy each substructure
   if (ant) anno->ant = ant->copy();
   return anno;
}

void
DjVuAnno::merge(const GP<DjVuAnno> & anno)
{
   if (anno)
   {
      GP<ByteStream> gstr=ByteStream::create();
      encode(gstr);
      anno->encode(gstr);
      gstr->seek(0);
      decode(gstr);
   }
}


#ifdef HAVE_NAMESPACES
}
# ifndef NOT_USING_DJVU_NAMESPACE
using namespace DJVU;
# endif
#endif