hwpfilter/source/hbox.h

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