hwpfilter/source/hwpfile.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
  21 // hwpfile.h
  22 // (C) 1998 Mizi Research, All rights are reserved
  23
  24
  25 #ifndef INCLUDED_HWPFILTER_SOURCE_HWPFILE_H
  26 #define INCLUDED_HWPFILTER_SOURCE_HWPFILE_H
  27
  28 #include <algorithm>
  29 #include <memory>
  30 #include <vector>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <fcntl.h>
  34 #include <sal/types.h>
  35 #include "hwplib.h"
  36 #include "hfont.h"
  37 #include "hstyle.h"
  38 #include "hpara.h"
  39
  40 #define HWPIDLen    30
  41 #define V20SIGNATURE    "HWP Document File V2.00 \032\1\2\3\4\5"
  42 #define V21SIGNATURE    "HWP Document File V2.10 \032\1\2\3\4\5"
  43 #define V30SIGNATURE    "HWP Document File V3.00 \032\1\2\3\4\5"
  44
  45 #define HWP_V20 20
  46 #define HWP_V21 21
  47 #define HWP_V30 30
  48
  49 int detect_hwp_version(const char *str);
  50
  51 struct  FBox;
  52 struct  EmPicture;
  53 struct  HyperText;
  54 struct  FBoxStyle;
  55 struct  CellLine;
  56 struct  Cell;
  57 struct  OlePicture;
  58 struct  Picture;
  59 struct  HeaderFooter;
  60 struct  ShowPageNum;
  61 struct  DateCode;
  62 struct  Table;
  63
  64 class   HIODev;
  65 class   HWPInfo;
  66 class   HWPFont;
  67 class   HWPStyle;
  68 class   HWPPara;
  69 class   HStream;
  70
  71 struct HWPColumnInfo{
  72     int start_page;
  73     bool bIsSet;
  74     std::shared_ptr<ColumnDef> xColdef;
  75     explicit HWPColumnInfo(int num){
  76         start_page = num;
  77         bIsSet = false;
  78     }
  79 };
  80
  81 /**
  82  * The HWPFile class is the main class of hwp for reading file
  83  * information from stream
  84  *
  85  * The example is as below:
  86  * <pre>
  87  * HWPFile f;
  88  * f.ReadHwpFile( stream );
  89  * </pre>
  90  *
  91  * There are two way to read hwp information from stream, one is to read all at a time
  92  * to use @ref ReadhwpFile() method like above example, other is to read partial information
  93  * to use @ref Open(), @ref InfoRead(), @ref FontRead(), @ref StyleRead(), @ref ParaListRead(), @ref TagsRead(),
  94  *
  95  * @short HWP file management object
  96  */
  97 class DLLEXPORT HWPFile
  98 {
  99     public:
 100 /**
 101  * Default constructor
 102  */
 103         HWPFile();
 104         ~HWPFile();
 105
 106     public:
 107
 108 /**
 109  * Opens HStream to use it.
 110  * @returns 0 if success, otherwise error code
 111  * @see State()
 112  */
 113         int Open( std::unique_ptr<HStream> );
 114
 115 /**
 116  * Say current state
 117  * @returns 0 if normal, otherwise error code. If it's  bigger than USER_ERROR_BIT, it is internally using error, otherwise it's system error which is able to get the message @ref strerror() method.
 118  */
 119         int State( void ) const { return error_code;}
 120 /**
 121  * Sets the current state
 122  */
 123         int SetState(int errcode);
 124 /**
 125  * Reads one byte from HIODev
 126  */
 127         bool Read1b(unsigned char &out);
 128         bool Read1b(char &out);
 129 /**
 130  * Reads two byte from HIODev
 131  */
 132         bool Read2b(unsigned short &out);
 133         bool Read2b(char16_t &out);
 134 /**
 135  * Reads four byte from HIODev
 136  */
 137         bool Read4b(unsigned int &out);
 138         bool Read4b(int &out);
 139 /**
 140  * Reads nmemb short type array from HIODev
 141  */
 142         size_t Read2b(void *ptr, size_t nmemb);
 143
 144 /**
 145  * Reads some bytes from HIODev not regarding endian's way
 146  * @param size Amount for reading
 147  */
 148         size_t ReadBlock( void *ptr, size_t size );
 149 /**
 150  * Skips some bytes from HIODev
 151  */
 152         size_t SkipBlock( size_t size );
 153 /**
 154  * Reads main paragraph list
 155  */
 156         void ReadParaList(std::vector<std::unique_ptr<HWPPara>> &aplist, unsigned char flag = 0);
 157         void ReadParaList(std::vector<HWPPara*> &aplist);
 158 /**
 159  * Sets if the stream is compressed
 160  */
 161         void SetCompressed( bool );
 162 /**
 163  * Sets current HIODev
 164  */
 165         std::unique_ptr<HIODev> SetIODevice( std::unique_ptr<HIODev> hiodev );
 166
 167 /**
 168  * Reads all information of hwp file from stream
 169  */
 170         int ReadHwpFile( std::unique_ptr<HStream> );
 171 /**
 172  * Reads document information of hwp file from HIODev
 173  */
 174         void InfoRead(void);
 175 /**
 176  * Reads font list of hwp file from HIODev
 177  */
 178         void FontRead(void);
 179 /**
 180  * Reads style list of hwp file from HIODev
 181  */
 182         void StyleRead(void);
 183 /**
 184  * Reads paragraph list of hwp file from HIODev
 185  */
 186         void ParaListRead();
 187 /* 그림 등의 추가 정보를 읽는다. */
 188 /**
 189  * Reads additional information like embedded image of hwp file from HIODev
 190  */
 191         void TagsRead();
 192
 193         enum Paper
 194         {
 195             UserPaper = 0,
 196             Col80Paper = 1,
 197             Col132Paper = 2,
 198             A4Paper = 3,
 199             LetterPaper = 4,
 200             B5Paper = 5,
 201             B4Paper = 6,
 202             LegalPaper = 7,
 203             A3Paper = 8
 204         };
 205
 206         void AddPage(){ m_nCurrentPage++;}
 207         void AddColumnInfo();
 208         void SetColumnDef(std::shared_ptr<ColumnDef> const &);
 209         void AddParaShape(std::shared_ptr<ParaShape> const &);
 210         void AddCharShape(std::shared_ptr<CharShape> const &);
 211         void AddFBoxStyle(FBoxStyle *);
 212         void AddDateFormat(DateCode *);
 213         void AddHeaderFooter(HeaderFooter *);
 214         void AddPageNumber(ShowPageNum *);
 215         void AddTable(std::unique_ptr<Table>);
 216
 217         ColumnDef* GetColumnDef(int);
 218           int GetPageMasterNum(int page);
 219
 220         int getCurrentPage() const{ return m_nCurrentPage;}
 221         HWPInfo& GetHWPInfo(void) { return _hwpInfo; }
 222         HWPFont& GetHWPFont(void) { return _hwpFont; }
 223         HWPStyle& GetHWPStyle(void) { return _hwpStyle; }
 224         HWPPara *GetFirstPara(void) { return !plist.empty() ? plist.front().get() : nullptr; }
 225
 226         EmPicture *GetEmPicture(Picture *pic);
 227         EmPicture *GetEmPictureByName(char * name);
 228         HyperText *GetHyperText();
 229         ParaShape *getParaShape(int);
 230         CharShape *getCharShape(int);
 231         FBoxStyle *getFBoxStyle(int);
 232         DateCode *getDateCode(int);
 233           HeaderFooter *getHeaderFooter(int);
 234         ShowPageNum *getPageNumber(int);
 235           Table *getTable(int);
 236
 237         int getParaShapeCount() const{ return pslist.size(); }
 238         int getCharShapeCount() const{ return cslist.size(); }
 239         int getFBoxStyleCount() const{ return fbslist.size(); }
 240         int getDateFormatCount() const{ return datecodes.size(); }
 241         int getHeaderFooterCount() const{ return headerfooters.size(); }
 242         int getPageNumberCount() const{ return pagenumbers.size(); }
 243         int getTableCount() const{ return tables.size(); }
 244         int getColumnCount() const{ return columnlist.size(); }
 245
 246           int getMaxSettedPage() const{ return m_nMaxSettedPage; }
 247           void setMaxSettedPage(){ m_nMaxSettedPage = m_nCurrentPage; }
 248
 249         void push_hpara_type(unsigned char scflag) { element_import_stack.push_back(scflag); }
 250         bool already_importing_type(unsigned char scflag) const
 251         {
 252             return std::find(element_import_stack.begin(), element_import_stack.end(), scflag) != element_import_stack.end();
 253         }
 254         void pop_hpara_type() { element_import_stack.pop_back(); }
 255
 256         void move_to_failed(std::unique_ptr<HWPPara> rPara);
 257
 258     private:
 259         int compareCharShape(CharShape const *shape);
 260         int compareParaShape(ParaShape const *shape);
 261
 262     public:
 263         int   version;
 264         bool  compressed;
 265         bool  encrypted;
 266         unsigned char linenumber;
 267         int   info_block_len;
 268         int   error_code;
 269         std::unique_ptr<OlePicture> oledata;
 270         unsigned char scratch[SAL_MAX_UINT16];
 271         int readdepth;
 272
 273     private:
 274 /* hwp 파일 이름 */
 275         int m_nCurrentPage;
 276         int m_nMaxSettedPage;
 277         std::unique_ptr<HIODev> hiodev;
 278 // read hwp contents
 279         HWPInfo   _hwpInfo;
 280         HWPFont   _hwpFont;
 281         HWPStyle  _hwpStyle;
 282         std::vector<std::unique_ptr<HWPColumnInfo>> columnlist;
 283         // paragraph list
 284         std::vector<std::unique_ptr<HWPPara>> plist;
 285         // keep paragraph's that failed to load until
 286         // import is complete to avoid dangling references
 287         // elsewhere
 288         std::vector<std::unique_ptr<HWPPara>> pfailedlist;
 289         // embedded picture list(tag data)
 290         std::vector<std::unique_ptr<EmPicture>> emblist;
 291         std::vector<std::unique_ptr<HyperText>> hyperlist;
 292         int currenthyper;
 293         std::vector<std::shared_ptr<ParaShape>> pslist;
 294         std::vector<std::shared_ptr<CharShape>> cslist;
 295         std::vector<FBoxStyle*> fbslist;
 296         std::vector<DateCode*> datecodes;
 297         std::vector<HeaderFooter*> headerfooters;
 298         std::vector<ShowPageNum*> pagenumbers;
 299         std::vector<std::unique_ptr<Table>> tables;
 300         //track the stack of HParas types we're currently importing
 301         std::vector<unsigned char> element_import_stack;
 302
 303 // for global document handling
 304         static HWPFile *cur_doc;
 305         friend HWPFile *GetCurrentDoc(void);
 306         friend HWPFile *SetCurrentDoc(HWPFile *);
 307 };
 308
 309 class DLLEXPORT DepthGuard
 310 {
 311 private:
 312     HWPFile& m_rFile;
 313 public:
 314     DepthGuard(HWPFile &rFile)
 315         : m_rFile(rFile)
 316     {
 317         ++m_rFile.readdepth;
 318     }
 319     bool toodeep() const
 320     {
 321         return m_rFile.readdepth == 512;
 322     }
 323     ~DepthGuard()
 324     {
 325         --m_rFile.readdepth;
 326     }
 327 };
 328
 329 HWPFile *GetCurrentDoc(void);
 330 HWPFile *SetCurrentDoc(HWPFile *hwpfp);
 331 #endif // INCLUDED_HWPFILTER_SOURCE_HWPFILE_H
 332
 333 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */