hwpfilter/source/hbox.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #ifndef _HBOX_H_
  30 #define _HBOX_H_
  31
  32 #include <list>
  33
  34 #include "hwplib.h"
  35 #include "hwpfile.h"
  36 #include "hinfo.h"
  37 #include "hpara.h"
  38
  39 /**
  40  * The HBox class is the base class for all date classes in hwp document.
  41  * For example, there are special character, table, image, etc.
  42  * It has one character. The ascii code value of special characters are smaller than 32. General character is greater than 32.
  43  *
  44  * @short Base class for characters
  45  */
  46 struct HBox
  47 {
  48     public:
  49         hchar hh;
  50
  51 /**
  52  * Construct a HBox object with parameter hch.
  53  * @param hch 16bit character being able to have Korean character.
  54  */
  55         HBox( hchar hch );
  56         virtual ~HBox();
  57 /**
  58  * @returns The Size of HBox object
  59  */
  60         virtual int   WSize();
  61 /**
  62  * @returns The Height of HBox object as hunit value.
  63  */
  64         virtual hunit Height(CharShape *csty);
  65 /**
  66  * Read properties from HIODevice object like stream, file, memory.
  67  *
  68  * @param hwpf HWPFile Object having all information for a hwp file.
  69  * @returns True if reading from stream is successful.
  70  */
  71         virtual int   Read(HWPFile &hwpf);
  72
  73         virtual hchar_string GetString();
  74     private:
  75         static int boxCount;
  76 };
  77
  78 /**
  79  * @short Class for saving data to be skipped.
  80  */
  81 struct SkipData: public HBox
  82 {
  83     ulong data_block_len;
  84     hchar dummy;
  85     char  *data_block;
  86
  87     SkipData(hchar);
  88     virtual ~SkipData();
  89     virtual int Read(HWPFile &hwpf);
  90 };
  91 struct DateCode;
  92 struct FieldCode : public HBox
  93 {
  94     uchar type[2];                    /* 2/0 - °è»ê½Ä, 3/0-¹®¼¿ä¾à, 3/1-°³ÀÎÁ¤º¸, 3/2-¸¸µç³¯Â¥, 4/0-´©¸§Æ² */
  95     char *reserved1;
  96     unsigned short location_info;     /* 0 - ³¡ÄÚµå, 1 - ½ÃÀÛÄÚµå */
  97     char *reserved2;
  98     hchar *str1;
  99     hchar *str2;
 100     hchar *str3;
 101     char *bin;
 102
 103      DateCode *m_pDate;
 104
 105     FieldCode();
 106     virtual ~FieldCode();
 107     virtual int Read(HWPFile &hwpf);
 108 };
 109 /**
 110  * Kind of BOOKMARK
 111  */
 112 enum
 113 {
 114     BM_MARK,
 115     BM_BEGIN,
 116     BM_END
 117 };
 118
 119 #define BMK_COMMENT_LEN 15
 120
 121 /**
 122  * @short Class for BOOKMARK
 123  */
 124 struct Bookmark: public HBox
 125 {
 126     hchar         dummy;
 127     hchar         id[BMK_COMMENT_LEN + 1];
 128     unsigned short    type;
 129
 130     Bookmark();
 131     virtual ~Bookmark();
 132     virtual int Read(HWPFile &hwpf);
 133 };
 134
 135 // date format(7)
 136 const int DATE_SIZE = 40;
 137
 138 /**
 139  * @short Class for saving date format made by user
 140  */
 141 struct DateFormat: public HBox
 142 {
 143     hchar format[DATE_SIZE];
 144     hchar dummy;
 145
 146     DateFormat();
 147     virtual int Read(HWPFile &hwpf);
 148 };
 149
 150 /**
 151  * @short Class for current date and time with specified format.
 152  */
 153 struct DateCode: public HBox
 154 {
 155     enum
 156     {
 157         YEAR, MONTH, WEEK, DAY, HOUR, MIN
 158     };
 159
 160     hchar format[DATE_SIZE];
 161 /**
 162  * year/month/week/day/hour/minute
 163  */
 164     short date[6];
 165     hchar dummy;
 166     unsigned char key;
 167
 168     DateCode();
 169     virtual int Read(HWPFile &hwpf);
 170
 171     virtual hchar_string GetString();
 172 };
 173
 174 /**
 175  * @short Tab object
 176  */
 177 struct Tab: public HBox
 178 {
 179     hunit width;
 180     unsigned short leader;
 181     hchar dummy;
 182
 183     Tab();
 184     virtual int Read(HWPFile &hwpf);
 185 };
 186
 187 // tbox(10) TABLE BOX MATH BUTTON HYPERTEXT
 188
 189 enum ttype { TBL_TYPE, TXT_TYPE, EQU_TYPE, BUTTON_TYPE, HYPERTEXT_TYPE };
 190 enum                                              /* TxtBox->margin[n][?] */
 191 {
 192     OUT_M, IN_M, CELL_M
 193 };
 194 enum                                              /* TxtBox->margin[?][n] */
 195 {
 196     L_M, R_M, T_M, B_M
 197 };
 198 enum anchor { CHAR_ANCHOR, PARA_ANCHOR, PAGE_ANCHOR, PAPER_ANCHOR };
 199 enum { TF_OCCUPY_SPACE, TF_TRANSPARENT,TF_ARROUND_TEXT };
 200 enum
 201 {
 202     CAP_OUT_BOT,  CAP_OUT_TOP,  CAP_IN_BOT,    CAP_IN_TOP,
 203     CAP_LEFT_BOT, CAP_LEFT_TOP, CAP_RIGHT_BOT, CAP_RIGHT_TOP,
 204     EQU_CAP_POS
 205 };
 206
 207 /**
 208  * Definitions for frame's common 'option' member.
 209  */
 210 #define DRAW_FRAME      1                         /* <-> no frame, bit 0 */
 211 #define NORMAL_PIC      2                         /* <-> reverse,  bit 1 */
 212 #define FIT_TO_COLUMN   4                         /* fig_xs is columnlen */
 213 #define UNKNOWN_FILE    8                         /* need check reverse for pcx mono */
 214 #define HYPERTEXT_FLAG  16
 215 #define UNKNOWN_SIZE    32
 216 #define FOPT_TEMP_BIT   0x00010000                /* temporary starts from 16th bits */
 217
 218 struct CellLine
 219 {
 220     unsigned char key;
 221     unsigned char top;                            // 0 - ¶óÀÎ¾øÀ½, 1-single, 2-thick, 3-double
 222     unsigned char bottom;
 223     unsigned char left;
 224     unsigned char right;
 225     short color;                                  // cell color
 226     unsigned char shade;                          // <100%
 227 };
 228 /**
 229  * A cell has four properties to specify the position for itself in hwp.
 230  * @li xpos -  distance between left border of cell and left border of table
 231  * @li ypos -  distance between top border of cell and top border of table
 232  * @li width -  distance between left border of cell and right border of cell
 233  * @li height -  distance between top border of cell and bottom border of table
 234  * This is differ from the format of other office in fact cell has two properties
 235  * - rowindex and column index.
 236  *
 237  * @short Cell object
 238  */
 239 struct Cell                                       // Cell
 240 {
 241     unsigned char key;                            // Index value of border style
 242     short     p;
 243     short     color;                              // cell color
 244     short     x, y;                               // [x,y] cell pos
 245     short     w, h;                               // [x,y] cell size
 246     short     txthigh, cellhigh;                  // used maximum
 247     unsigned char flag, changed, used;            // unused(file)
 248     unsigned char ver_align;                      // vertical align  {1=center}
 249     unsigned char linetype[4];                    // [left,right,top,bottom]
 250     unsigned char shade;                          // <100%
 251     unsigned char diagonal;                       // { 0=none,\=1,/=2,X=3}
 252     unsigned char protect;
 253
 254     void  Read( HWPFile &hwpf );
 255 };
 256
 257 /**
 258  * @short Style for floating object
 259  */
 260 struct FBoxStyle
 261 {
 262 /**
 263  * Anchor type : paragraph , page, char
 264  */
 265     unsigned char anchor_type;
 266 /**
 267  * Kind of wrap
 268  */
 269     unsigned char txtflow;                        /* ±×¸²ÇÇÇÔ. 0-2(ÀÚ¸®Â÷Áö,Åõ¸í,¾î¿ï¸²) */
 270 /**
 271  * Horizontal alignment
 272  */
 273     short     xpos;                               // left, right, center, xx
 274 /**
 275  * Vertical alignment
 276  */
 277     short     ypos;                               // page top, bottom, yy
 278 /**
 279  * Every margin of border
 280  * [0-2][] : out/in/cell margin
 281  * [][0-3] : left/right/top/bottom
 282  */
 283     short     margin[3][4];                       // out : left, right, top, bottom
 284 /**
 285  * Index of floating object
 286  */
 287     short     boxnum;                             /* ½ºÅ¸¿ÀÇÇ½º¿¡¼ ½ºÅ¸ÀÏ ÀÌ¸§À¸·Î »ç¿ëµÉ ¼ýÀÚ */
 288 /**
 289  * Type of floating object : line, txtbox, image, table, equalizer and button
 290  */
 291     unsigned char boxtype;                        // (L)ine, t(X)tbox, Picture - (G)
 292     short     cap_len; /* Ä¸¼ÇÀÇ ±æÀÌ */
 293
 294     void *cell;
 295
 296 };
 297
 298 /**
 299  * This object is for floating object like table, image, line and so on.
 300  *
 301  * @short floating object
 302  */
 303 struct FBox: public HBox
 304 {
 305     int zorder;
 306     short     option;                             // draw frame
 307     hchar     ctrl_ch;
 308     FBoxStyle style;
 309
 310     short     box_xs, box_ys;
 311     short     cap_xs, cap_ys ;
 312     short     xs, ys;                             // ys = fig_ys + cap_ys + margin
 313 // xs = fig_xs + cap_xs + margin
 314     short     cap_margin;
 315     char      xpos_type, ypos_type;
 316     unsigned char smart_linesp;
 317
 318 /*  ÀÌ ÀÚ·á´Â tbox³ª pic¿¡¼´Â ÆÄÀÏ¿¡ ±â·ÏÇÏÁö ¾Ê°í ½ÇÇà½Ã¸¸ ÀÖÀ¸¸ç,
 319     line¿¡¼´Â ÆÄÀÏ¿¡ ±â·ÏÇÑ´Ù.
 320  */
 321     short     boundsy, boundey;
 322     unsigned char boundx, draw;
 323
 324 /**
 325  * Physical x,y position.
 326  */
 327     short     pgx, pgy;                           // physical xpos, ypos
 328     short     pgno, showpg;                       // pageno where code is
 329
 330     FBox      *prev, *next;
 331
 332     FBox( hchar hch );
 333     virtual ~FBox();
 334 };
 335
 336 struct Table;
 337 /**
 338  * The TxtBox class saves object properties about table, textbox, equalizer or button
 339  */
 340 struct TxtBox: public FBox
 341 {
 342     hchar     reserved[2];
 343     hchar     dummy;
 344
 345     short     dummy1;                             // to not change structure size */
 346     short     cap_len;
 347     short     next;
 348     short     dummy2;                             // to not change structure size */
 349     unsigned char reserved1;
 350 /**
 351  * caption position
 352  */
 353     short     cap_pos;                            // caption pos
 354     short     num;                                // numbering
 355
 356     short     dummy3;
 357     short     baseline;                           //(for equ)
 358
 359 /**
 360  * The value of type indicates as the below: zero is table, one is
 361  * textbox, two is equalizer and three is button.
 362  */
 363     short     type;                               // 0-table, 1-textbox, 2-¼ö½Ä, 3-button
 364 /**
 365  * nCell is greater than one only for table, otherwise it is 1.
 366  */
 367     short     nCell;                              //:=1    offset 80
 368 /**
 369  * If value of protect is 1, size of cell cann't change.
 370  */
 371     short     protect;                            //1=size lock
 372
 373     Cell      *cell;
 374      Table *m_pTable;
 375 /**
 376  * Paragraph list
 377  */
 378     std::list<HWPPara*> *plists;
 379 /**
 380  * Caption
 381  */
 382     std::list<HWPPara*> caption;
 383
 384     TxtBox();
 385     virtual ~TxtBox();
 386
 387 /**
 388  * @returns Count of cell.
 389  */
 390     virtual int NCell()   { return nCell; }
 391 /**
 392  * This is one of table, text-box, equalizer and button
 393  * @returns Type of this object.
 394  */
 395     virtual int Type()    { return type;  }
 396
 397     virtual int Read(HWPFile &hwpf);
 398
 399     virtual hunit  Height(CharShape *csty);
 400 };
 401
 402 #define ALLOWED_GAP 5
 403 #define INIT_SIZE 20
 404 #define ADD_AMOUNT 10
 405
 406 struct Columns
 407 {
 408      int *data;
 409      size_t nCount;
 410      size_t nTotal;
 411      Columns(){
 412           nCount = 0;
 413           nTotal = INIT_SIZE;
 414           data = new int[nTotal];
 415      }
 416      ~Columns(){ delete[] data; }
 417
 418      void AddColumnsSize(){
 419           int *tmp = data;
 420           if (nTotal + ADD_AMOUNT < nTotal) // overflow
 421           {
 422               throw ::std::bad_alloc();
 423           }
 424           data = new int[nTotal + ADD_AMOUNT];
 425           for (size_t i = 0 ; i < nTotal ; i++)
 426                 data[i] = tmp[i];
 427           nTotal += ADD_AMOUNT;
 428           delete[] tmp;
 429      }
 430
 431      void insert(int pos){
 432           if( nCount == 0 ){
 433                 data[nCount++] = pos;
 434                 return;
 435           }
 436           for (size_t i = 0 ; i < nCount; i++ ) {
 437                 if( pos < data[i] + ALLOWED_GAP && pos > data[i] - ALLOWED_GAP )
 438                      return;  // Already exist;
 439                 if( pos < data[i] ){
 440                      if( nCount == nTotal )
 441                           AddColumnsSize();
 442                      for (size_t j = nCount ; j > i ; j--)
 443                           data[j] = data[j-1];
 444                      data[i] = pos;
 445                      nCount++;
 446                      return;
 447                 }
 448           }
 449           // last postion.
 450           if( nCount == nTotal )
 451                 AddColumnsSize();
 452           data[nCount++] = pos;
 453      }
 454
 455      int getIndex(int pos)
 456      {
 457           if( pos == 0 )
 458                 return 0;
 459           for (size_t i = 0 ; i < nCount; i++) {
 460                 if( pos < data[i] + ALLOWED_GAP && pos > data[i] - ALLOWED_GAP )
 461                      return i;
 462           }
 463           return -1;
 464      }
 465 };
 466
 467 struct Rows
 468 {
 469      int *data;
 470      size_t nCount;
 471      size_t nTotal;
 472      Rows(){
 473           nCount = 0;
 474           nTotal = INIT_SIZE;
 475           data = new int[nTotal];
 476      }
 477      ~Rows(){ delete[] data; }
 478
 479      void AddRowsSize(){
 480           int *tmp = data;
 481           if (nTotal + ADD_AMOUNT < nTotal) // overflow
 482           {
 483               throw ::std::bad_alloc();
 484           }
 485           data = new int[nTotal + ADD_AMOUNT];
 486           for (size_t i = 0 ; i < nTotal ; i++)
 487                 data[i] = tmp[i];
 488           nTotal += ADD_AMOUNT;
 489           delete[] tmp;
 490      }
 491
 492      void insert(int pos){
 493           if( nCount == 0 ){
 494                 data[nCount++] = pos;
 495                 return;
 496           }
 497           for (size_t i = 0 ; i < nCount; i++) {
 498                 if( pos < data[i] + ALLOWED_GAP && pos > data[i] - ALLOWED_GAP )
 499                      return;  // Already exist;
 500                 if( pos < data[i] ){
 501                      if( nCount == nTotal )
 502                           AddRowsSize();
 503                      for (size_t j = nCount ; j > i ; j--)
 504                           data[j] = data[j-1];
 505                      data[i] = pos;
 506                      nCount++;
 507                      return;
 508                 }
 509           }
 510           // last postion.
 511           if( nCount == nTotal )
 512                 AddRowsSize();
 513           data[nCount++] = pos;
 514      }
 515
 516      int getIndex(int pos)
 517      {
 518           if( pos == 0 )
 519                 return 0;
 520           for (size_t i = 0 ; i < nCount; i++) {
 521                 if( pos < data[i] + ALLOWED_GAP && pos > data[i] - ALLOWED_GAP )
 522                      return i;
 523           }
 524           return -1;
 525      }
 526 };
 527
 528 struct TCell
 529 {
 530      int nColumnIndex;
 531      int nRowIndex;
 532      int nColumnSpan;
 533      int nRowSpan;
 534      Cell *pCell;
 535 };
 536
 537 struct Table
 538 {
 539      Table(){};
 540      ~Table(){
 541           std::list<TCell*>::iterator it = cells.begin();
 542           for( ; it != cells.end(); ++it)
 543                 delete *it;
 544      };
 545      Columns columns;
 546      Rows rows;
 547     std::list<TCell*> cells;
 548      TxtBox *box;
 549 };
 550
 551 /* picture (11) ±×¸², OLE±×¸², »ðÀÔ±×¸², ±×¸®±â */
 552 enum pictype
 553 {
 554     PICTYPE_FILE, PICTYPE_OLE, PICTYPE_EMBED,
 555     PICTYPE_DRAW, PICTYPE_UNKNOWN
 556 };
 557 /**
 558  * @short External image file
 559  */
 560 struct PicDefFile
 561 {
 562     char path[256];
 563     void *img;
 564     bool skipfind;
 565 };
 566
 567 /**
 568  * @short Embeded image file
 569  */
 570 struct PicDefEmbed
 571 {
 572     char  embname[16];
 573 };
 574
 575 /**
 576  * @short Win32 ole object
 577  */
 578 struct PicDefOle
 579 {
 580     char  embname[16];
 581     void  *hwpole;
 582 };
 583
 584 /**
 585  * @short Drawing object of hwp
 586  */
 587 struct PicDefDraw
 588 {
 589     void      *hdo;
 590     uint      zorder;
 591     ZZRect    vrect;
 592     int       mbrcnt;
 593 };
 594
 595 /**
 596  * @short For using common case
 597  */
 598 struct PicDefUnknown
 599 {
 600     char  path[256];
 601 };
 602
 603 typedef union
 604 {
 605     PicDefFile        picfile;
 606     PicDefEmbed       picembed;
 607     PicDefOle     picole;
 608     PicDefDraw        picdraw;
 609     PicDefUnknown     picun;
 610 } PicDef;
 611
 612 #define PIC_INFO_LEN    348
 613 /**
 614  * There are four kinds of image.
 615  * @li External image
 616  * @li Embeded image
 617  * @li Win32 ole object
 618  * @li Drawing object of hwp
 619  *
 620  * @short Image object
 621  */
 622 struct Picture: public FBox
 623 {
 624     hchar     reserved[2];
 625     hchar     dummy;
 626 /**
 627  * follow_block_size is the size information of the Drawing object of hwp.
 628  * It's value is greater than 0 if the pictype is PICTYPE_DRAW.
 629  */
 630     ulong     follow_block_size;                  /* Ãß°¡Á¤º¸ ±æÀÌ. */
 631     short     dummy1;                             // to not change structure size */
 632     short     dummy2;                             // to not change structure size */
 633     uchar     reserved1;
 634 /**
 635  * Position of caption
 636  */
 637     short     cap_pos;                            // caption pos
 638 /**
 639  * Index of current Picture object
 640  */
 641     short     num;                                // numbering
 642
 643 /**
 644  * Type of this object
 645  * It is one of external/ole/embeded/drawing picture
 646  */
 647     uchar     pictype;
 648     hunit     skip[2];
 649 /**
 650  * Ratio of magnification or reduction.
 651  */
 652     hunit     scale[2];
 653     PicDef    picinfo;
 654     char      reserved3[9];
 655
 656     std::list<HWPPara*> caption;
 657 /**
 658  * It's for the Drawing object
 659  */
 660     unsigned char *follow;                        /* ±×¸²Á¾·ù°¡ drawingÀÏ¶§, Ãß°¡Á¤º¸. */
 661
 662     bool ishyper;
 663
 664     Picture();
 665     virtual ~Picture();
 666
 667     virtual int   Type    ();
 668     virtual int   Read    (HWPFile &hwpf);
 669
 670     virtual hunit  Height (CharShape *sty);
 671 };
 672
 673 // line (14)
 674 /**
 675  * @short Line
 676  */
 677 struct Line: public FBox
 678 {
 679     hchar     reserved[2];
 680     hchar     dummy;
 681
 682     char      reserved2[8];
 683
 684     short     sx, sy, ex, ey;
 685     short     width, shade, color;
 686
 687     Line();
 688
 689     virtual int Read(HWPFile &hwpf);
 690 };
 691
 692 // hidden(15)
 693 /**
 694  * @short Hidden section
 695  */
 696 struct Hidden: public HBox
 697 {
 698     hchar     reserved[2];
 699     hchar     dummy;
 700
 701     unsigned char info[8];                        // h, next, dummy
 702     std::list<HWPPara*> plist;
 703
 704     Hidden();
 705     virtual ~Hidden();
 706
 707     virtual int Read(HWPFile &hwpf);
 708 };
 709
 710 /**
 711  * @short Header or footer
 712  */
 713 struct HeaderFooter: public HBox
 714 {
 715     hchar     reserved[2];
 716     hchar     dummy;
 717
 718     unsigned char info[8];
 719 /**
 720  * Header or footer
 721  */
 722     unsigned char type;
 723     unsigned char where;
 724     unsigned char linenumber;
 725
 726      unsigned int m_nPageNumber;
 727
 728 /**
 729  * Paragraph list of header or footer
 730  */
 731     std::list<HWPPara*> plist;
 732
 733     HeaderFooter();
 734     virtual ~HeaderFooter();
 735
 736     virtual int Read(HWPFile &hwpf);
 737 };
 738
 739 /**
 740  * Both footnote and endnote are comment. Footnote is located at the end of paragraph; endnote is located at the end of page. The Footnote class represents footnote and endnote.
 741  * @short Footnote or endnote
 742  */
 743 struct Footnote: public HBox
 744 {
 745     hchar     reserved[2];
 746     hchar     dummy;
 747
 748     unsigned char  info[8];
 749 /**
 750  * The number of current footnote/endnote
 751  */
 752     unsigned short number;
 753 /**
 754  * Set the type of Footnote either footnote or endnote.
 755  */
 756     unsigned short type;
 757 /**
 758  * The width of the Footnote object.
 759  */
 760     hunit     width;
 761 /**
 762  * Paragraph list of Footnote objects
 763  */
 764     std::list<HWPPara*> plist;
 765
 766     Footnote();
 767     virtual ~Footnote();
 768
 769     virtual int Read(HWPFile &hwpf);
 770 };
 771
 772 // auto number(18)
 773 /**
 774  * Kind of auto input number
 775  */
 776 enum
 777 {
 778     PGNUM_AUTO,
 779     FNNUM_AUTO,
 780     ENNUM_AUTO,
 781     PICNUM_AUTO,
 782     TBLNUM_AUTO,
 783     EQUNUM_AUTO
 784 };
 785
 786 /**
 787  * @short Input current index of page,comment,table and picture.
 788  */
 789 struct AutoNum: public HBox
 790 {
 791     unsigned short type;
 792     unsigned short number;
 793     hchar      dummy;
 794
 795     AutoNum();
 796
 797     virtual int Read(HWPFile &hwpf);
 798 };
 799
 800 /**
 801  * @short Input new number as current index of page,comment,table and picture.
 802  */
 803 struct NewNum: public HBox
 804 {
 805     unsigned short type;
 806     unsigned short number;
 807     hchar      dummy;
 808
 809     NewNum();
 810
 811     virtual int Read(HWPFile &hwpf);
 812 };
 813
 814 // page numger(20)
 815 /**
 816  * @short Input page index in footer or header
 817  */
 818 struct ShowPageNum: public HBox
 819 {
 820 /**
 821  * Location of page number to be inserted.
 822  */
 823     unsigned short where;
 824      unsigned int m_nPageNumber;
 825 /**
 826  * Shape of page number to be inserted.
 827  */
 828     unsigned short shape;
 829     hchar      dummy;
 830
 831     ShowPageNum();
 832
 833     virtual int Read(HWPFile &hwpf);
 834 };
 835
 836 /* È¦¼öÂÊ½ÃÀÛ (21) */
 837 #define HIDE_HD         1                         /* bit 0 */
 838 #define HIDE_FT         2                         /* bit 1 */
 839 #define HIDE_PGNUM      4                         /* bit 2 */
 840 #define HIDE_FRAME      8                         /* bit 3 */
 841 /**
 842  * Controls the display of page number, header, footer and border.
 843  */
 844 struct PageNumCtrl: public HBox
 845 {
 846 /**
 847  * object type
 848  */
 849     unsigned short kind;
 850 /**
 851  * control command.
 852  */
 853     unsigned short what;
 854     hchar      dummy;
 855
 856     PageNumCtrl();
 857
 858     virtual int Read(HWPFile &hwpf);
 859 };
 860
 861 // mail merge(22)
 862 /**
 863  * Generates the mailing list automatically using address book and mail body format.
 864  * @short Generates mailing list
 865  */
 866 struct MailMerge: public HBox
 867 {
 868     unsigned char field_name[20];
 869     hchar     dummy;
 870
 871     MailMerge();
 872
 873     virtual int Read(HWPFile &hwpf);
 874     virtual hchar_string GetString();
 875 };
 876
 877 // char compositon(23)
 878 /**
 879  * The compose struct displays characters at position. The maximum character count for composition is three.
 880  * @short Composition several characters
 881  */
 882 struct Compose: public HBox
 883 {
 884     hchar     compose[3];
 885     hchar     dummy;
 886
 887     Compose();
 888
 889     virtual int Read(HWPFile &hwpf);
 890 };
 891
 892 // hyphen(24)
 893 /**
 894  * @short Hyphen
 895  */
 896 struct Hyphen: public HBox
 897 {
 898 /**
 899  * Width of hyphen
 900  */
 901     hchar     width;
 902     hchar     dummy;
 903
 904     Hyphen();
 905
 906     virtual int Read(HWPFile &hwpf);
 907 };
 908
 909 // toc mark(25)
 910 /**
 911  * The TocMark class is for making the content of a table.
 912  * When you set TocMark on current position, hwp makes it as toc automatically.
 913  * @short Table of contents
 914  */
 915 struct TocMark: public HBox
 916 {
 917     hchar     kind;
 918     hchar     dummy;
 919
 920     TocMark();
 921
 922     virtual int Read(HWPFile &hwpf);
 923 };
 924
 925 // index mark(26)
 926 /**
 927  * IndexMark marks the table of search.
 928  * If you set IndexMark at current position, hwp make it as search index.
 929  * @short Table of search
 930  */
 931 struct IndexMark: public HBox
 932 {
 933     hchar     keyword1[60];
 934     hchar     keyword2[60];
 935     unsigned short pgno;
 936     hchar     dummy;
 937
 938     IndexMark();
 939
 940     virtual int Read(HWPFile &hwpf);
 941 };
 942
 943 // outline(28)
 944 #define MAX_OUTLINE_LEVEL   7
 945
 946 enum
 947 {
 948     OLSTY_USER = 0,
 949     OLSTY_NUMS1 = 1,
 950     OLSTY_NUMS2 = 2,
 951     OLSTY_NUMSIG1 = 3,
 952     OLSTY_NUMSIG2 = 4,
 953     OLSTY_NUMSIG3 = 5,
 954     OLSTY_BULUSER = 128,
 955     OLSTY_BULLET1 = 129,
 956     OLSTY_BULLET2 = 130,
 957     OLSTY_BULLET3 = 131,
 958     OLSTY_BULLET4 = 132,
 959     OLSTY_BULLET5 = 133
 960 };
 961
 962 // value is in style->userchar[level];
 963 enum
 964 {
 965     UDO_NUM,
 966     UDO_UROM,
 967     UDO_LROM,
 968     UDO_UENG,
 969     UDO_LENG,
 970     UDO_SYLL,
 971     UDO_JAMO,
 972     UDO_HANJA,
 973     UDO_SP_CNUM,
 974     UDO_SP_CLENG,
 975     UDO_SP_CSYLL,
 976     UDO_SP_CJAMO,
 977     N_UDO
 978 };
 979 /**
 980  * Number and format of title.
 981  * @short Number and format of title
 982  */
 983 class Outline: public HBox
 984 {
 985     public:
 986 /**
 987  * kind of numbering format
 988  */
 989         unsigned short kind;
 990         unsigned char  shape;
 991 /**
 992  * level of number, Ex) The level of 1.3.2.4 is four
 993  */
 994         unsigned char  level;
 995 /**
 996  * value of level
 997  */
 998         unsigned short number[MAX_OUTLINE_LEVEL];
 999 /**
1000  * shape of level
1001  */
1002         hchar     user_shape[MAX_OUTLINE_LEVEL];
1003 /**
1004  * decoration charactor for the level type
1005  */
1006         hchar     deco[MAX_OUTLINE_LEVEL][2];     /* »ç¿ëÀÚ Á¤ÀÇ½Ã ¾ÕµÚ ¹®ÀÚ */
1007         hchar     dummy;
1008
1009         Outline();
1010
1011         virtual int   Read(HWPFile &hwpf);
1012         hchar_string GetUnicode() const;
1013 };
1014
1015 /* ¹À½ ºóÄ(30) */
1016 /**
1017  * The Special space to be treated non-space when a string is
1018  * cut at the end of line
1019  * @short Special space
1020  */
1021 struct KeepSpace: public HBox
1022 {
1023     hchar dummy;
1024
1025     KeepSpace();
1026
1027     virtual int Read(HWPFile &hwpf);
1028 };
1029
1030 /* °íÁ¤Æø ºóÄ(31) */
1031 /**
1032  * @short Space with always same width not relation with fonts.
1033  */
1034 struct FixedSpace: public HBox
1035 {
1036     hchar     dummy;
1037
1038     FixedSpace();
1039
1040     virtual int Read(HWPFile &hwpf);
1041 };
1042 #endif                                            /* _HBOX_H_ */
1043
1044 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */