Line data    Source code

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