hwpfilter/source/hbox.h

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