hwpfilter/source/hwpfile.cxx

   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 #include "precompile.h"
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include "hwplib.h"
  27 #include "hwpfile.h"
  28 #include "hiodev.h"
  29 #include "hfont.h"
  30 #include "hstyle.h"
  31 #include "hbox.h"
  32 #include "hpara.h"
  33 #include "htags.h"
  34 #include "hcode.h"
  35 #include "hstream.hxx"
  36
  37 #include <osl/diagnose.h>
  38
  39 HWPFile *HWPFile::cur_doc = 0;
  40 static int ccount = 0;
  41 static int pcount = 0;
  42 static int datecodecount = 0;
  43
  44 HWPFile::HWPFile()
  45     : version(HWP_V30)
  46     , compressed(false)
  47     , encrypted(false)
  48     , linenumber(0)
  49     , info_block_len(0)
  50     , error_code(HWP_NoError)
  51     , oledata(0)
  52     , m_nCurrentPage(1)
  53     , m_nMaxSettedPage(0)
  54     , hiodev(0)
  55     , currenthyper(0)
  56 {
  57     SetCurrentDoc(this);
  58 }
  59
  60 HWPFile::~HWPFile()
  61 {
  62     delete oledata;
  63     delete hiodev;
  64
  65     std::list < ColumnInfo* >::iterator it_column = columnlist.begin();
  66     for (; it_column != columnlist.end(); ++it_column)
  67         delete *it_column;
  68
  69     std::list < HWPPara* >::iterator it = plist.begin();
  70     for (; it != plist.end(); ++it)
  71         delete *it;
  72
  73     std::list < Table* >::iterator tbl = tables.begin();
  74     for (; tbl != tables.end(); ++tbl)
  75         delete *tbl;
  76
  77     std::list < HyperText* >::iterator hyp = hyperlist.begin();
  78     for (; hyp != hyperlist.end(); ++hyp)
  79     {
  80         delete *hyp;
  81     }
  82 }
  83
  84 int HWPFile::ReadHwpFile(HStream * stream)
  85 {
  86     if (Open(stream) != HWP_NoError)
  87         return State();
  88     InfoRead();
  89     FontRead();
  90     StyleRead();
  91     AddColumnInfo();
  92     ParaListRead();
  93     TagsRead();
  94
  95     return State();
  96 }
  97
  98 int detect_hwp_version(const char *str)
  99 {
 100     if (memcmp(V20SIGNATURE, str, HWPIDLen) == 0)
 101         return HWP_V20;
 102     else if (memcmp(V21SIGNATURE, str, HWPIDLen) == 0)
 103         return HWP_V21;
 104     else if (memcmp(V30SIGNATURE, str, HWPIDLen) == 0)
 105         return HWP_V30;
 106     return 0;
 107 }
 108
 109 // HIODev wrapper
 110
 111 int HWPFile::Open(HStream * stream)
 112 {
 113     HStreamIODev *hstreamio = new HStreamIODev(stream);
 114
 115     if (!hstreamio->open())
 116     {
 117         delete hstreamio;
 118
 119         return SetState(HWP_EMPTY_FILE);
 120     }
 121
 122     HIODev *pPrev = SetIODevice(hstreamio);
 123     delete pPrev;
 124
 125     char idstr[HWPIDLen];
 126
 127     if (ReadBlock(idstr, HWPIDLen) <= 0
 128         || HWP_V30 != (version = detect_hwp_version(idstr)))
 129     {
 130         return SetState(HWP_UNSUPPORTED_VERSION);
 131     }
 132     return HWP_NoError;
 133 }
 134
 135 int HWPFile::SetState(int errcode)
 136 {
 137     error_code = errcode;
 138     return error_code;
 139 }
 140
 141 bool HWPFile::Read1b(unsigned char &out)
 142 {
 143     return hiodev && hiodev->read1b(out);
 144 }
 145
 146 bool HWPFile::Read1b(char &out)
 147 {
 148     unsigned char tmp8;
 149     if (!Read1b(tmp8))
 150         return false;
 151     out = tmp8;
 152     return true;
 153 }
 154
 155 bool HWPFile::Read2b(unsigned short &out)
 156 {
 157     return hiodev && hiodev->read2b(out);
 158 }
 159
 160 bool HWPFile::Read4b(unsigned int &out)
 161 {
 162     return hiodev && hiodev->read4b(out);
 163 }
 164
 165 bool HWPFile::Read4b(int &out)
 166 {
 167     unsigned int tmp32;
 168     if (!Read4b(tmp32))
 169         return false;
 170     out = tmp32;
 171     return true;
 172 }
 173
 174 int HWPFile::Read1b(void *ptr, size_t nmemb)
 175 {
 176     return hiodev ? hiodev->read1b(ptr, nmemb) : 0;
 177 }
 178
 179 int HWPFile::Read2b(void *ptr, size_t nmemb)
 180 {
 181     return hiodev ? hiodev->read2b(ptr, nmemb) : 0;
 182 }
 183
 184
 185 int HWPFile::Read4b(void *ptr, size_t nmemb)
 186 {
 187     return hiodev ? hiodev->read4b(ptr, nmemb) : 0;
 188 }
 189
 190
 191 size_t HWPFile::ReadBlock(void *ptr, size_t size)
 192 {
 193     return hiodev ? hiodev->readBlock(ptr, size) : 0;
 194 }
 195
 196
 197 size_t HWPFile::SkipBlock(size_t size)
 198 {
 199     return hiodev ? hiodev->skipBlock(size) : 0;
 200 }
 201
 202
 203 bool HWPFile::SetCompressed(bool flag)
 204 {
 205     return hiodev && hiodev->setCompressed(flag);
 206 }
 207
 208
 209 HIODev *HWPFile::SetIODevice(HIODev * new_hiodev)
 210 {
 211     HIODev *old_hiodev = hiodev;
 212
 213     hiodev = new_hiodev;
 214
 215     return old_hiodev;
 216 }
 217
 218
 219 // end of HIODev wrapper
 220
 221 bool HWPFile::InfoRead()
 222 {
 223     return _hwpInfo.Read(*this);
 224 }
 225
 226
 227 bool HWPFile::FontRead()
 228 {
 229     return _hwpFont.Read(*this);
 230 }
 231
 232
 233 bool HWPFile::StyleRead()
 234 {
 235     return _hwpStyle.Read(*this);
 236 }
 237
 238
 239 bool HWPFile::ParaListRead()
 240 {
 241     return ReadParaList(plist);
 242 }
 243
 244 bool HWPFile::ReadParaList(std::list < HWPPara* > &aplist, unsigned char flag)
 245 {
 246     HWPPara *spNode = new HWPPara;
 247      unsigned char tmp_etcflag;
 248      unsigned char prev_etcflag = 0;
 249     while (spNode->Read(*this, flag))
 250     {
 251          if( !(spNode->etcflag & 0x04) ){
 252           tmp_etcflag = spNode->etcflag;
 253           spNode->etcflag = prev_etcflag;
 254           prev_etcflag = tmp_etcflag;
 255          }
 256         if (spNode->nch && spNode->reuse_shape)
 257         {
 258             if (!aplist.empty()){
 259                      spNode->pshape = aplist.back()->pshape;
 260                 }
 261                 else{
 262                      spNode->nch = 0;
 263                      spNode->reuse_shape = 0;
 264                 }
 265         }
 266           spNode->pshape.pagebreak = spNode->etcflag;
 267           if( spNode->nch )
 268                 AddParaShape( &spNode->pshape );
 269
 270         if (!aplist.empty())
 271             aplist.back()->SetNext(spNode);
 272         aplist.push_back(spNode);
 273         spNode = new HWPPara;
 274     }
 275     delete spNode;
 276
 277     return true;
 278 }
 279
 280 void HWPFile::TagsRead()
 281 {
 282     while (true)
 283     {
 284         uint tag;
 285         if (!Read4b(tag))
 286             return;
 287         int size;
 288         if (!Read4b(size))
 289             return;
 290         if (size <= 0 && tag > 0){
 291             continue;
 292           }
 293
 294         if (tag == FILETAG_END_OF_COMPRESSED ||
 295             tag == FILETAG_END_OF_UNCOMPRESSED)
 296             return;
 297         switch (tag)
 298         {
 299             case FILETAG_EMBEDDED_PICTURE:
 300             {
 301                 EmPicture *emb = new EmPicture(size);
 302
 303                 if (emb->Read(*this))
 304                     emblist.push_back(emb);
 305                 else
 306                     delete emb;
 307             }
 308             break;
 309             case FILETAG_OLE_OBJECT:
 310                 if (oledata)
 311                     delete oledata;
 312                 oledata = new OlePicture(size);
 313                 oledata->Read(*this);
 314                 break;
 315             case FILETAG_HYPERTEXT:
 316             {
 317                 if( (size % 617) != 0 )
 318                     SkipBlock( size );
 319                 else
 320                 {
 321                     for( int i = 0 ; i < size/617 ; i++)
 322                     {
 323                         HyperText *hypert = new HyperText;
 324                         hypert->Read(*this);
 325                         hyperlist.push_back(hypert);
 326                     }
 327                 }
 328                 break;
 329             }
 330                 case 6:
 331                 {
 332                      ReadBlock(_hwpInfo.back_info.reserved1, 8);
 333                      if (!Read4b(_hwpInfo.back_info.luminance))
 334                         return;
 335                      if (!Read4b(_hwpInfo.back_info.contrast))
 336                         return;
 337                      if (!Read1b(_hwpInfo.back_info.effect))
 338                         return;
 339                      ReadBlock(_hwpInfo.back_info.reserved2, 7);
 340                      ReadBlock(_hwpInfo.back_info.filename, 260);
 341                      ReadBlock(_hwpInfo.back_info.color, 3);
 342                      unsigned short nFlag;
 343                      if (!Read2b(nFlag))
 344                         return;
 345                      _hwpInfo.back_info.flag = nFlag >> 8 ;
 346                      int nRange;
 347                      if (!Read4b(nRange))
 348                         return;
 349                      _hwpInfo.back_info.range = nRange >> 24;
 350                      ReadBlock(_hwpInfo.back_info.reserved3, 27);
 351                      if (!Read4b(_hwpInfo.back_info.size))
 352                         return;
 353
 354                      _hwpInfo.back_info.data = new char[(unsigned int)_hwpInfo.back_info.size];
 355                      ReadBlock(_hwpInfo.back_info.data, _hwpInfo.back_info.size);
 356
 357                      if( _hwpInfo.back_info.size > 0 )
 358                           _hwpInfo.back_info.type = 2;
 359                      else if( _hwpInfo.back_info.filename[0] )
 360                           _hwpInfo.back_info.type = 1;
 361                      else
 362                           _hwpInfo.back_info.type = 0;
 363
 364
 365                      _hwpInfo.back_info.isset = true;
 366
 367                      break;
 368                 }
 369             case FILETAG_PRESENTATION:
 370             case FILETAG_PREVIEW_IMAGE:
 371             case FILETAG_PREVIEW_TEXT:
 372             default:
 373                 SkipBlock(size);
 374         }
 375     }
 376 }
 377
 378
 379 ColumnDef *HWPFile::GetColumnDef(int num)
 380 {
 381     std::list<ColumnInfo*>::iterator it = columnlist.begin();
 382
 383     for(int i = 0; it != columnlist.end() ; ++it, i++){
 384         if( i == num )
 385           break;
 386     }
 387
 388     if( it != columnlist.end() )
 389         return (*it)->coldef;
 390     else
 391         return 0;
 392 }
 393 /* @return 인덱스는 1부터 시작한다. */
 394 int HWPFile::GetPageMasterNum(int page)
 395 {
 396     std::list<ColumnInfo*>::iterator it = columnlist.begin();
 397     int i;
 398
 399     for( i = 1 ; it != columnlist.end() ; ++it, i++){
 400         ColumnInfo *now = *it;
 401         if( page < now->start_page )
 402             return i-1;
 403     }
 404     return i-1;
 405 }
 406
 407 HyperText *HWPFile::GetHyperText()
 408 {
 409     std::list<HyperText*>::iterator it = hyperlist.begin();
 410
 411     for( int i = 0; it != hyperlist.end(); ++it, i++ ){
 412         if( i == currenthyper )
 413           break;
 414     }
 415
 416     currenthyper++;
 417     return it != hyperlist.end() ? *it : NULL;
 418 }
 419
 420 EmPicture *HWPFile::GetEmPicture(Picture * pic)
 421 {
 422     char *name = pic->picinfo.picembed.embname;
 423
 424     name[0] = 'H';
 425     name[1] = 'W';
 426     name[2] = 'P';
 427
 428     std::list < EmPicture* >::iterator it = emblist.begin();
 429     for (; it != emblist.end(); ++it)
 430         if (strcmp(name, (*it)->name) == 0)
 431             return *it;
 432     return 0;
 433 }
 434
 435 EmPicture *HWPFile::GetEmPictureByName(char * name)
 436 {
 437     name[0] = 'H';
 438     name[1] = 'W';
 439     name[2] = 'P';
 440
 441     std::list < EmPicture* >::iterator it = emblist.begin();
 442     for (; it != emblist.end(); ++it)
 443         if (strcmp(name, (*it)->name) == 0)
 444             return *it;
 445     return 0;
 446 }
 447
 448
 449 void HWPFile::AddBox(FBox * box)
 450 {
 451 // LATER if we don't use box->next(),
 452 // AddBox() and GetBoxHead() are useless;
 453     if (!blist.empty())
 454     {
 455         box->prev = blist.back();
 456         box->prev->next = box;
 457     }
 458     else
 459         box->prev = 0;
 460     blist.push_back(box);
 461 }
 462
 463
 464 ParaShape *HWPFile::getParaShape(int index)
 465 {
 466     std::list<ParaShape*>::iterator it = pslist.begin();
 467
 468     for( int i = 0; it != pslist.end(); ++it, i++ ){
 469         if( i == index )
 470           break;
 471     }
 472
 473     return it != pslist.end() ? *it : NULL;
 474 }
 475
 476
 477 CharShape *HWPFile::getCharShape(int index)
 478 {
 479     std::list<CharShape*>::iterator it = cslist.begin();
 480
 481     for( int i = 0; it != cslist.end(); ++it, i++ ){
 482         if( i == index )
 483           break;
 484     }
 485
 486     return it != cslist.end() ? *it : 0;
 487 }
 488
 489
 490 FBoxStyle *HWPFile::getFBoxStyle(int index)
 491 {
 492     std::list<FBoxStyle*>::iterator it = fbslist.begin();
 493
 494     for( int i = 0; it != fbslist.end(); ++it, i++ ){
 495         if( i == index )
 496           break;
 497     }
 498
 499     return it != fbslist.end() ? *it : 0;
 500 }
 501
 502 DateCode *HWPFile::getDateCode(int index)
 503 {
 504     std::list<DateCode*>::iterator it = datecodes.begin();
 505
 506     for( int i = 0; it != datecodes.end(); ++it, i++ ){
 507         if( i == index )
 508           break;
 509     }
 510
 511     return it != datecodes.end() ? *it : NULL;
 512 }
 513
 514 HeaderFooter *HWPFile::getHeaderFooter(int index)
 515 {
 516     std::list<HeaderFooter*>::iterator it = headerfooters.begin();
 517
 518     for( int i = 0; it != headerfooters.end(); ++it, i++ ){
 519         if( i == index )
 520           break;
 521     }
 522
 523     return it != headerfooters.end() ? *it : NULL;
 524 }
 525
 526 ShowPageNum *HWPFile::getPageNumber(int index)
 527 {
 528     std::list<ShowPageNum*>::iterator it = pagenumbers.begin();
 529
 530     for( int i = 0; it != pagenumbers.end(); ++it, i++ ){
 531         if( i == index )
 532           break;
 533     }
 534
 535     return it != pagenumbers.end() ? *it : NULL;
 536
 537 }
 538
 539 Table *HWPFile::getTable(int index)
 540 {
 541     std::list<Table*>::iterator it = tables.begin();
 542
 543     for( int i = 0; it != tables.end(); ++it, i++ ){
 544         if( i == index )
 545           break;
 546     }
 547
 548     return it != tables.end() ? *it : NULL;
 549 }
 550
 551 void HWPFile::AddParaShape(ParaShape * pshape)
 552 {
 553     int nscount = 0;
 554     for(int j = 0 ; j < MAXTABS-1 ; j++)
 555     {
 556           if( j > 0 && pshape->tabs[j].position == 0 )
 557                 break;
 558           if( pshape->tabs[0].position == 0 ){
 559                 if( pshape->tabs[j].type || pshape->tabs[j].dot_continue ||
 560                      (pshape->tabs[j].position != 1000 *j) )
 561                           nscount = j;
 562           }
 563           else{
 564                 if( pshape->tabs[j].type || pshape->tabs[j].dot_continue ||
 565                      (pshape->tabs[j].position != 1000 * (j + 1)) )
 566                           nscount = j;
 567           }
 568     }
 569     if( nscount )
 570         pshape->tabs[MAXTABS-1].type = sal::static_int_cast<char>(nscount);
 571      int value = compareParaShape(pshape);
 572     if( value == 0 || nscount )
 573     {
 574         pshape->index = ++pcount;
 575         pslist.push_back(pshape);
 576     }
 577     else
 578         pshape->index = value;
 579 }
 580
 581
 582 void HWPFile::AddCharShape(CharShape * cshape)
 583 {
 584     int value = compareCharShape(cshape);
 585     if( value == 0 )
 586     {
 587         cshape->index = ++ccount;
 588         cslist.push_back(cshape);
 589     }
 590     else
 591         cshape->index = value;
 592 }
 593
 594 void HWPFile::AddColumnInfo()
 595 {
 596     ColumnInfo *cinfo = new ColumnInfo(m_nCurrentPage);
 597     columnlist.push_back(cinfo);
 598     setMaxSettedPage();
 599 }
 600
 601 void HWPFile::SetColumnDef(ColumnDef *coldef)
 602 {
 603     ColumnInfo *cinfo = columnlist.back();
 604     if( cinfo->bIsSet )
 605         return;
 606     cinfo->coldef = coldef;
 607     cinfo->bIsSet = true;
 608 }
 609
 610 void HWPFile::AddDateFormat(DateCode * hbox)
 611 {
 612     hbox->key = sal::static_int_cast<char>(++datecodecount);
 613     datecodes.push_back(hbox);
 614 }
 615
 616 void HWPFile::AddPageNumber(ShowPageNum * hbox)
 617 {
 618     pagenumbers.push_back(hbox);
 619 }
 620
 621 void HWPFile::AddHeaderFooter(HeaderFooter * hbox)
 622 {
 623     headerfooters.push_back(hbox);
 624 }
 625
 626 void HWPFile::AddTable(Table * hbox)
 627 {
 628     tables.push_back(hbox);
 629 }
 630
 631 void HWPFile::AddFBoxStyle(FBoxStyle * fbstyle)
 632 {
 633     fbslist.push_back(fbstyle);
 634 }
 635
 636 int HWPFile::compareCharShape(CharShape *shape)
 637 {
 638     int count = cslist.size();
 639     if( count > 0 )
 640     {
 641         for(int i = 0; i< count; i++)
 642         {
 643             CharShape *cshape = getCharShape(i);
 644
 645             if( shape->size == cshape->size &&
 646                 shape->font[0] == cshape->font[0] &&
 647                 shape->ratio[0] == cshape->ratio[0] &&
 648                 shape->space[0] == cshape->space[0] &&
 649                 shape->color[1] == cshape->color[1] &&
 650                 shape->color[0] == cshape->color[0] &&
 651                 shape->shade == cshape->shade &&
 652                 shape->attr == cshape->attr )
 653             {
 654                 return cshape->index;
 655             }
 656         }
 657     }
 658     return 0;
 659 }
 660
 661
 662 int HWPFile::compareParaShape(ParaShape *shape)
 663 {
 664     int count = pslist.size();
 665     if( count > 0 )
 666     {
 667         for(int i = 0; i< count; i++)
 668         {
 669             ParaShape *pshape = getParaShape(i);
 670             if( shape->left_margin == pshape->left_margin &&
 671                 shape->right_margin == pshape->right_margin &&
 672                 shape->pspacing_prev == pshape->pspacing_prev &&
 673                 shape->pspacing_next == pshape->pspacing_next &&
 674                 shape->indent == pshape->indent &&
 675                 shape->lspacing == pshape->lspacing &&
 676                 shape->arrange_type == pshape->arrange_type &&
 677                 shape->outline == pshape->outline  &&
 678                      shape->pagebreak == pshape->pagebreak)
 679             {
 680                     if( shape->cshape && pshape->cshape &&
 681                          shape->cshape->size == pshape->cshape->size &&
 682                          shape->cshape->font[0] == pshape->cshape->font[0] &&
 683                          shape->cshape->ratio[0] == pshape->cshape->ratio[0] &&
 684                          shape->cshape->space[0] == pshape->cshape->space[0] &&
 685                          shape->cshape->color[1] == pshape->cshape->color[1] &&
 686                          shape->cshape->color[0] == pshape->cshape->color[0] &&
 687                          shape->cshape->shade == pshape->cshape->shade &&
 688                          shape->cshape->attr == pshape->cshape->attr )
 689                     {
 690                          return pshape->index;
 691                     }
 692             }
 693         }
 694     }
 695     return 0;
 696 }
 697
 698
 699 HWPFile *GetCurrentDoc()
 700 {
 701     return HWPFile::cur_doc;
 702 }
 703
 704
 705 HWPFile *SetCurrentDoc(HWPFile * hwpfp)
 706 {
 707     HWPFile *org = HWPFile::cur_doc;
 708
 709     HWPFile::cur_doc = hwpfp;
 710     return org;
 711 }
 712
 713 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */