AOO410/main/hwpfilter/source/hwpfile.cpp - openoffice - Git at Google

 /**************************************************************
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  *************************************************************/


 #include "precompile.h"

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include "hwplib.h"
 #include "hwpfile.h"
 #include "hiodev.h"
 #include "hfont.h"
 #include "hstyle.h"
 #include "hbox.h"
 #include "hpara.h"
 #include "htags.h"
 #include "hcode.h"
 #include "hstream.h"

 #define HWPIDLen    30
 #define HWPHeadLen  128
 #define HWPSummaryLen   1008

 #define V20SIGNATURE    "HWP Document File V2.00 \032\1\2\3\4\5"
 #define V21SIGNATURE    "HWP Document File V2.10 \032\1\2\3\4\5"
 #define V30SIGNATURE    "HWP Document File V3.00 \032\1\2\3\4\5"

 #define FILESTG_SIGNATURE       0xF8995567
 #define FILESTG_SIGNATURE_NORMAL    0xF8995568

 HWPFile *HWPFile::cur_doc = 0;
 static int ccount = 0;
 static int pcount = 0;
 static int datecodecount = 0;

 HWPFile::HWPFile(void)
 {
     Init();
 }


 /**
  * TODO : 추가된 스타일리스트에 대한 메모리 해제
  */
 HWPFile::~HWPFile(void)
 {
     if (oledata)
         delete oledata;

     if (hiodev)
         delete hiodev;

     LinkedListIterator < ColumnInfo > it_column(&columnlist);
     for (; it_column.current(); it_column++)
         delete it_column.current();

     LinkedListIterator < HWPPara > it(&plist);
     for (; it.current(); it++)
         delete it.current();

     LinkedListIterator < Table > tbl(&tables);
     for (; tbl.current(); tbl++)
         delete tbl.current();

     LinkedListIterator < HyperText > hyp(&hyperlist);
     for (; hyp.current(); hyp++)
     {
         delete hyp.current();
     }
 }


 void HWPFile::Init(void)
 {
     version = HWP_V30;
     info_block_len = 0;
     compressed = false;
     encrypted = false;

     error_code = HWP_NoError;
     hiodev = 0;
     oledata = 0;
     SetCurrentDoc(this);
     currenthyper = 0;
 	 m_nCurrentPage = 1;
 	 m_nMaxSettedPage = 0;
 }


 int HWPFile::ReadHwpFile(HStream & stream)
 {
     if (Open(stream) != HWP_NoError)
         return State();
 //	printf("HWPFile::ReadHwpFile\n");
     InfoRead();
 //	printf("HWPFile::InfoRead Done.\n");
     FontRead();
 //	printf("HWPFile::FontRead Done.\n");
     StyleRead();
 //	printf("HWPFile::StyleRead Done.\n");
 	AddColumnInfo();
     ParaListRead();
 //	printf("HWPFile::ParaListRead Done.\n");
     TagsRead();
 	//printf("HWPFile::TagsRead Done. State: %d\n", State());

     return State();
 }


 static int hwp_version(char *str)
 {
     if (memcmp(V20SIGNATURE, str, HWPIDLen) == 0)
         return HWP_V20;
     else if (memcmp(V21SIGNATURE, str, HWPIDLen) == 0)
         return HWP_V21;
     else if (memcmp(V30SIGNATURE, str, HWPIDLen) == 0)
         return HWP_V30;
     return 0;
 }


 // HIODev wrapper

 int HWPFile::Open(HStream & stream)
 {
     HStreamIODev *hstreamio;

     if (0 == (hstreamio = new HStreamIODev(stream)))
     {
         printf(" hstreamio is not instanciate \n");
         return SetState(errno);
     }
     if (!hstreamio->open())
     {
         delete hstreamio;

         return SetState(HWP_EMPTY_FILE);
     }
     SetIODevice(hstreamio);

     char idstr[HWPIDLen];

     if (ReadBlock(idstr, HWPIDLen) <= 0
         || HWP_V30 != (version = hwp_version(idstr)))
     {
         return SetState(HWP_UNSUPPORTED_VERSION);
     }
     return HWP_NoError;
 }


 int HWPFile::State(void) const
 {
     return error_code;
 }


 int HWPFile::SetState(int errcode)
 {
     error_code = errcode;
     return error_code;
 }


 int HWPFile::Read1b(void)
 {
     return hiodev ? hiodev->read1b() : -1;
 }


 int HWPFile::Read2b(void)
 {
     return hiodev ? hiodev->read2b() : -1;
 }


 long HWPFile::Read4b(void)
 {
     return hiodev ? hiodev->read4b() : -1;
 }


 int HWPFile::Read1b(void *ptr, size_t nmemb)
 {
     return hiodev ? hiodev->read1b(ptr, nmemb) : 0;
 }


 int HWPFile::Read2b(void *ptr, size_t nmemb)
 {
     return hiodev ? hiodev->read2b(ptr, nmemb) : 0;
 }


 int HWPFile::Read4b(void *ptr, size_t nmemb)
 {
     return hiodev ? hiodev->read4b(ptr, nmemb) : 0;
 }


 size_t HWPFile::ReadBlock(void *ptr, size_t size)
 {
     return hiodev ? hiodev->readBlock(ptr, size) : 0;
 }


 size_t HWPFile::SkipBlock(size_t size)
 {
     return hiodev ? hiodev->skipBlock(size) : 0;
 }


 bool HWPFile::SetCompressed(bool flag)
 {
     return hiodev ? hiodev->setCompressed(flag) : false;
 }


 HIODev *HWPFile::SetIODevice(HIODev * new_hiodev)
 {
     HIODev *old_hiodev = hiodev;

     hiodev = new_hiodev;
     return old_hiodev;
 }


 // end of HIODev wrapper

 bool HWPFile::InfoRead(void)
 {
     return _hwpInfo.Read(*this);
 }


 bool HWPFile::FontRead(void)
 {
     return _hwpFont.Read(*this);
 }


 bool HWPFile::StyleRead(void)
 {
     return _hwpStyle.Read(*this);
 }


 bool HWPFile::ParaListRead(void)
 {
     return ReadParaList(plist);
 }

 bool HWPFile::ReadParaList(LinkedList < HWPPara > &aplist, unsigned char flag)
 {
     LinkedListIterator < HWPPara > it(&aplist);

     HWPPara *spNode = new HWPPara;
 	 unsigned char tmp_etcflag;
 	 unsigned char prev_etcflag = 0;
     while (spNode->Read(*this, flag))
     {
 		 if( !(spNode->etcflag & 0x04) ){
 		  tmp_etcflag = spNode->etcflag;
 		  spNode->etcflag = prev_etcflag;
 		  prev_etcflag = tmp_etcflag;
 		 }
         if (spNode->nch && spNode->reuse_shape)
         {
             if (aplist.count()){
 					 spNode->pshape = aplist.last()->pshape;
 				}
 				else{
 					 spNode->nch = 0;
 					 spNode->reuse_shape = 0;
 				}
         }
 		  spNode->pshape.pagebreak = spNode->etcflag;
 		  if( spNode->nch )
 				AddParaShape( &spNode->pshape );

         if (aplist.count())
             aplist.last()->SetNext(spNode);
         aplist.insert(spNode, -1);
         spNode = new HWPPara;
     }
     delete spNode;

     return true;
 }


 bool HWPFile::TagsRead(void)
 {
     ulong tag;
     long size;

     while (1)
     {
         tag = Read4b();
         size = Read4b();
         if (size <= 0 && tag > 0){
             //return false;
             continue;
 		  }

         if (tag == FILETAG_END_OF_COMPRESSED ||
             tag == FILETAG_END_OF_UNCOMPRESSED)
             return true;
         switch (tag)
         {
             case FILETAG_EMBEDDED_PICTURE:
             {
                 EmPicture *emb = new EmPicture(size);

                 if (true == emb->Read(*this))
                     emblist.insert(emb, -1);
                 else
                     delete emb;
             }
             break;
             case FILETAG_OLE_OBJECT:
                 if (oledata)
                     delete oledata;
                 oledata = new OlePicture(size);
                 oledata->Read(*this);
                 break;
             case FILETAG_HYPERTEXT:
             {
                 if( (size % 617) != 0 )
                     SkipBlock( size );
                 else
                     for( int i = 0 ; i < size/617 ; i++)
                 {
                     HyperText *hypert = new HyperText;
                     hypert->Read(*this);
                     hyperlist.insert(hypert, -1);
                 }
                 break;
             }
 				case 6:
 				{
 					 ReadBlock(_hwpInfo.back_info.reserved1, 8);
 					 _hwpInfo.back_info.luminance = Read4b();
 					 _hwpInfo.back_info.contrast = Read4b();
                      _hwpInfo.back_info.effect = sal::static_int_cast<char>(Read1b());
 					 ReadBlock(_hwpInfo.back_info.reserved2, 7);
 					 ReadBlock(_hwpInfo.back_info.filename, 260);
 					 ReadBlock(_hwpInfo.back_info.color, 3);
                      unsigned short nFlag = sal::static_int_cast<unsigned short>(Read2b());
 					 _hwpInfo.back_info.flag = nFlag >> 8 ;
 					 int nRange = Read4b();
 					 _hwpInfo.back_info.range = nRange >> 24;
 					 ReadBlock(_hwpInfo.back_info.reserved3, 27);
 					 _hwpInfo.back_info.size = Read4b();

 					 _hwpInfo.back_info.data = new char[(unsigned int)_hwpInfo.back_info.size];
 					 ReadBlock(_hwpInfo.back_info.data, _hwpInfo.back_info.size);

 					 if( _hwpInfo.back_info.size > 0 )
 						  _hwpInfo.back_info.type = 2;
 					 else if( _hwpInfo.back_info.filename[0] )
 						  _hwpInfo.back_info.type = 1;
 					 else
 						  _hwpInfo.back_info.type = 0;


 					 _hwpInfo.back_info.isset = true;

 					 break;
 				}
             case FILETAG_PRESENTATION:
             case FILETAG_PREVIEW_IMAGE:
             case FILETAG_PREVIEW_TEXT:
             default:
                 SkipBlock(size);
         }
     }
 //    return false;
 }


 ColumnDef *HWPFile::GetColumnDef(int num)
 {
 	ColumnInfo *cinfo = columnlist.find(num);
 	if( cinfo )
 		return cinfo->coldef;
 	else
 		return 0;
 }
 /* @return 인덱스는 1부터 시작한다. */
 int HWPFile::GetPageMasterNum(int page)
 {
 	LinkedListIterator<ColumnInfo> it(&columnlist);
     //os: unused
     //ColumnInfo *prev = 0;
 	ColumnInfo *now = 0;
 	int i;

 	for( i = 1 ; it.current() ; it++, i++){
 		now = it.current();
 		if( page < now->start_page )
 			return i-1;
 	}
 	return i-1;
 }

 HyperText *HWPFile::GetHyperText()
 {
     return hyperlist.find(currenthyper++);
 }

 EmPicture *HWPFile::GetEmPicture(Picture * pic)
 {
     char *name = pic->picinfo.picembed.embname;

     name[0] = 'H';
     name[1] = 'W';
     name[2] = 'P';

     LinkedListIterator < EmPicture > it(&emblist);
     for (; it.current(); it++)
         if (strcmp(name, it.current()->name) == 0)
             return it.current();
     return 0;
 }

 EmPicture *HWPFile::GetEmPictureByName(char * name)
 {
     name[0] = 'H';
     name[1] = 'W';
     name[2] = 'P';

     LinkedListIterator < EmPicture > it(&emblist);
     for (; it.current(); it++)
         if (strcmp(name, it.current()->name) == 0)
             return it.current();
     return 0;
 }


 void HWPFile::AddBox(FBox * box)
 {
 // LATER if we don't use box->next(),
 // AddBox() and GetBoxHead() are useless;
     if (blist.count())
     {
         box->prev = blist.last();
         box->prev->next = box;
     }
     else
         box->prev = 0;
     blist.insert(box, -1);
 }


 ParaShape *HWPFile::getParaShape(int index)
 {
     return pslist.find(index);
 }


 CharShape *HWPFile::getCharShape(int index)
 {
     return cslist.find(index);
 }


 FBoxStyle *HWPFile::getFBoxStyle(int index)
 {
     return fbslist.find(index);
 }

 DateCode *HWPFile::getDateCode(int index)
 {
     return datecodes.find(index);
 }

 HeaderFooter *HWPFile::getHeaderFooter(int index)
 {
     return headerfooters.find(index);
 }

 ShowPageNum *HWPFile::getPageNumber(int index)
 {
     return pagenumbers.find(index);
 }

 Table *HWPFile::getTable(int index)
 {
     return tables.find(index);
 }

 void HWPFile::AddParaShape(ParaShape * pshape)
 {
     int nscount = 0;
     for(int j = 0 ; j < MAXTABS-1 ; j++)
     {
 		  if( j > 0 && pshape->tabs[j].position == 0 )
 				break;
 		  if( pshape->tabs[0].position == 0 ){
 				if( pshape->tabs[j].type || pshape->tabs[j].dot_continue ||
 					 (pshape->tabs[j].position != 1000 *j) )
 						  nscount = j;
 		  }
 		  else{
 				if( pshape->tabs[j].type || pshape->tabs[j].dot_continue ||
 					 (pshape->tabs[j].position != 1000 * (j + 1)) )
 						  nscount = j;
 		  }
     }
     if( nscount )
         pshape->tabs[MAXTABS-1].type = sal::static_int_cast<char>(nscount);
 	 int value = compareParaShape(pshape);
     if( value == 0 || nscount )
     {
         pshape->index = ++pcount;
         pslist.insert(pshape, -1);
     }
     else
         pshape->index = value;
 }


 void HWPFile::AddCharShape(CharShape * cshape)
 {
     int value = compareCharShape(cshape);
     if( value == 0 )
     {
         cshape->index = ++ccount;
         cslist.insert(cshape, -1);
     }
     else
         cshape->index = value;
 }

 void HWPFile::AddColumnInfo()
 {
 	ColumnInfo *cinfo = new ColumnInfo(m_nCurrentPage);
    columnlist.insert(cinfo, -1);
 	setMaxSettedPage();
 }

 void HWPFile::SetColumnDef(ColumnDef *coldef)
 {
 	ColumnInfo *cinfo = columnlist.last();
 	if( cinfo->bIsSet )
 		return;
 	cinfo->coldef = coldef;
 	cinfo->bIsSet = true;
 }

 void HWPFile::AddDateFormat(DateCode * hbox)
 {
     hbox->key = sal::static_int_cast<char>(++datecodecount);
     datecodes.insert(hbox, -1);
 }

 void HWPFile::AddPageNumber(ShowPageNum * hbox)
 {
     pagenumbers.insert(hbox, -1);
 }

 void HWPFile::AddHeaderFooter(HeaderFooter * hbox)
 {
     headerfooters.insert(hbox, -1);
 }

 void HWPFile::AddTable(Table * hbox)
 {
     tables.insert(hbox, -1);
 }

 void HWPFile::AddFBoxStyle(FBoxStyle * fbstyle)
 {
     fbslist.insert(fbstyle, -1);
 }

 int HWPFile::compareCharShape(CharShape *shape)
 {
     int count = cslist.count();
     if( count > 0 )
     {
         CharShape *cshape=0;
         for(int i = 0; i< count; i++)
         {
             cshape = cslist.find(i);

             if( shape->size == cshape->size &&
                 shape->font[0] == cshape->font[0] &&
                 shape->ratio[0] == cshape->ratio[0] &&
                 shape->space[0] == cshape->space[0] &&
                 shape->color[1] == cshape->color[1] &&
                 shape->color[0] == cshape->color[0] &&
                 shape->shade == cshape->shade &&
                 shape->attr == cshape->attr )
             {
                 return cshape->index;
             }
         }
     }
     return 0;
 }


 int HWPFile::compareParaShape(ParaShape *shape)
 {
     int count = pslist.count();
     if( count > 0 )
     {
         ParaShape *pshape=0;
         for(int i = 0; i< count; i++)
         {
             pshape = pslist.find(i);
             if( shape->left_margin == pshape->left_margin &&
                 shape->right_margin == pshape->right_margin &&
                 shape->pspacing_prev == pshape->pspacing_prev &&
                 shape->pspacing_next == pshape->pspacing_next &&
                 shape->indent == pshape->indent &&
                 shape->lspacing == pshape->lspacing &&
                 shape->arrange_type == pshape->arrange_type &&
                 shape->outline == pshape->outline  &&
 					 shape->pagebreak == pshape->pagebreak)
             {
 					if( shape->cshape->size == pshape->cshape->size &&
 						 shape->cshape->font[0] == pshape->cshape->font[0] &&
 						 shape->cshape->ratio[0] == pshape->cshape->ratio[0] &&
 						 shape->cshape->space[0] == pshape->cshape->space[0] &&
 						 shape->cshape->color[1] == pshape->cshape->color[1] &&
 						 shape->cshape->color[0] == pshape->cshape->color[0] &&
 						 shape->cshape->shade == pshape->cshape->shade &&
 						 shape->cshape->attr == pshape->cshape->attr )
 					{
 						 return pshape->index;
 					}
             }
         }
     }
     return 0;
 }


 HWPFile *GetCurrentDoc(void)
 {
     return HWPFile::cur_doc;
 }


 HWPFile *SetCurrentDoc(HWPFile * hwpfp)
 {
     HWPFile *org = HWPFile::cur_doc;

     HWPFile::cur_doc = hwpfp;
     return org;
 }
	/**************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*************************************************************/



	#include "precompile.h"

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>
	#include "hwplib.h"
	#include "hwpfile.h"
	#include "hiodev.h"
	#include "hfont.h"
	#include "hstyle.h"
	#include "hbox.h"
	#include "hpara.h"
	#include "htags.h"
	#include "hcode.h"
	#include "hstream.h"

	#define HWPIDLen 30
	#define HWPHeadLen 128
	#define HWPSummaryLen 1008

	#define V20SIGNATURE "HWP Document File V2.00 \032\1\2\3\4\5"
	#define V21SIGNATURE "HWP Document File V2.10 \032\1\2\3\4\5"
	#define V30SIGNATURE "HWP Document File V3.00 \032\1\2\3\4\5"

	#define FILESTG_SIGNATURE 0xF8995567
	#define FILESTG_SIGNATURE_NORMAL 0xF8995568

	HWPFile *HWPFile::cur_doc = 0;
	static int ccount = 0;
	static int pcount = 0;
	static int datecodecount = 0;

	HWPFile::HWPFile(void)
	{
	Init();
	}


	/**
	* TODO : 추가된 스타일리스트에 대한 메모리 해제
	*/
	HWPFile::~HWPFile(void)
	{
	if (oledata)
	delete oledata;

	if (hiodev)
	delete hiodev;

	LinkedListIterator < ColumnInfo > it_column(&columnlist);
	for (; it_column.current(); it_column++)
	delete it_column.current();

	LinkedListIterator < HWPPara > it(&plist);
	for (; it.current(); it++)
	delete it.current();

	LinkedListIterator < Table > tbl(&tables);
	for (; tbl.current(); tbl++)
	delete tbl.current();

	LinkedListIterator < HyperText > hyp(&hyperlist);
	for (; hyp.current(); hyp++)
	{
	delete hyp.current();
	}
	}


	void HWPFile::Init(void)
	{
	version = HWP_V30;
	info_block_len = 0;
	compressed = false;
	encrypted = false;

	error_code = HWP_NoError;
	hiodev = 0;
	oledata = 0;
	SetCurrentDoc(this);
	currenthyper = 0;
	m_nCurrentPage = 1;
	m_nMaxSettedPage = 0;
	}


	int HWPFile::ReadHwpFile(HStream & stream)
	{
	if (Open(stream) != HWP_NoError)
	return State();
	// printf("HWPFile::ReadHwpFile\n");
	InfoRead();
	// printf("HWPFile::InfoRead Done.\n");
	FontRead();
	// printf("HWPFile::FontRead Done.\n");
	StyleRead();
	// printf("HWPFile::StyleRead Done.\n");
	AddColumnInfo();
	ParaListRead();
	// printf("HWPFile::ParaListRead Done.\n");
	TagsRead();
	//printf("HWPFile::TagsRead Done. State: %d\n", State());

	return State();
	}


	static int hwp_version(char *str)
	{
	if (memcmp(V20SIGNATURE, str, HWPIDLen) == 0)
	return HWP_V20;
	else if (memcmp(V21SIGNATURE, str, HWPIDLen) == 0)
	return HWP_V21;
	else if (memcmp(V30SIGNATURE, str, HWPIDLen) == 0)
	return HWP_V30;
	return 0;
	}


	// HIODev wrapper

	int HWPFile::Open(HStream & stream)
	{
	HStreamIODev *hstreamio;

	if (0 == (hstreamio = new HStreamIODev(stream)))
	{
	printf(" hstreamio is not instanciate \n");
	return SetState(errno);
	}
	if (!hstreamio->open())
	{
	delete hstreamio;

	return SetState(HWP_EMPTY_FILE);
	}
	SetIODevice(hstreamio);

	char idstr[HWPIDLen];

	if (ReadBlock(idstr, HWPIDLen) <= 0
	\|\| HWP_V30 != (version = hwp_version(idstr)))
	{
	return SetState(HWP_UNSUPPORTED_VERSION);
	}
	return HWP_NoError;
	}


	int HWPFile::State(void) const
	{
	return error_code;
	}


	int HWPFile::SetState(int errcode)
	{
	error_code = errcode;
	return error_code;
	}


	int HWPFile::Read1b(void)
	{
	return hiodev ? hiodev->read1b() : -1;
	}


	int HWPFile::Read2b(void)
	{
	return hiodev ? hiodev->read2b() : -1;
	}


	long HWPFile::Read4b(void)
	{
	return hiodev ? hiodev->read4b() : -1;
	}


	int HWPFile::Read1b(void *ptr, size_t nmemb)
	{
	return hiodev ? hiodev->read1b(ptr, nmemb) : 0;
	}


	int HWPFile::Read2b(void *ptr, size_t nmemb)
	{
	return hiodev ? hiodev->read2b(ptr, nmemb) : 0;
	}


	int HWPFile::Read4b(void *ptr, size_t nmemb)
	{
	return hiodev ? hiodev->read4b(ptr, nmemb) : 0;
	}


	size_t HWPFile::ReadBlock(void *ptr, size_t size)
	{
	return hiodev ? hiodev->readBlock(ptr, size) : 0;
	}


	size_t HWPFile::SkipBlock(size_t size)
	{
	return hiodev ? hiodev->skipBlock(size) : 0;
	}


	bool HWPFile::SetCompressed(bool flag)
	{
	return hiodev ? hiodev->setCompressed(flag) : false;
	}


	HIODev HWPFile::SetIODevice(HIODev new_hiodev)
	{
	HIODev *old_hiodev = hiodev;

	hiodev = new_hiodev;
	return old_hiodev;
	}


	// end of HIODev wrapper

	bool HWPFile::InfoRead(void)
	{
	return _hwpInfo.Read(*this);
	}


	bool HWPFile::FontRead(void)
	{
	return _hwpFont.Read(*this);
	}


	bool HWPFile::StyleRead(void)
	{
	return _hwpStyle.Read(*this);
	}


	bool HWPFile::ParaListRead(void)
	{
	return ReadParaList(plist);
	}

	bool HWPFile::ReadParaList(LinkedList < HWPPara > &aplist, unsigned char flag)
	{
	LinkedListIterator < HWPPara > it(&aplist);

	HWPPara *spNode = new HWPPara;
	unsigned char tmp_etcflag;
	unsigned char prev_etcflag = 0;
	while (spNode->Read(*this, flag))
	{
	if( !(spNode->etcflag & 0x04) ){
	tmp_etcflag = spNode->etcflag;
	spNode->etcflag = prev_etcflag;
	prev_etcflag = tmp_etcflag;
	}
	if (spNode->nch && spNode->reuse_shape)
	{
	if (aplist.count()){
	spNode->pshape = aplist.last()->pshape;
	}
	else{
	spNode->nch = 0;
	spNode->reuse_shape = 0;
	}
	}
	spNode->pshape.pagebreak = spNode->etcflag;
	if( spNode->nch )
	AddParaShape( &spNode->pshape );

	if (aplist.count())
	aplist.last()->SetNext(spNode);
	aplist.insert(spNode, -1);
	spNode = new HWPPara;
	}
	delete spNode;

	return true;
	}


	bool HWPFile::TagsRead(void)
	{
	ulong tag;
	long size;

	while (1)
	{
	tag = Read4b();
	size = Read4b();
	if (size <= 0 && tag > 0){
	//return false;
	continue;
	}

	if (tag == FILETAG_END_OF_COMPRESSED \|\|
	tag == FILETAG_END_OF_UNCOMPRESSED)
	return true;
	switch (tag)
	{
	case FILETAG_EMBEDDED_PICTURE:
	{
	EmPicture *emb = new EmPicture(size);

	if (true == emb->Read(*this))
	emblist.insert(emb, -1);
	else
	delete emb;
	}
	break;
	case FILETAG_OLE_OBJECT:
	if (oledata)
	delete oledata;
	oledata = new OlePicture(size);
	oledata->Read(*this);
	break;
	case FILETAG_HYPERTEXT:
	{
	if( (size % 617) != 0 )
	SkipBlock( size );
	else
	for( int i = 0 ; i < size/617 ; i++)
	{
	HyperText *hypert = new HyperText;
	hypert->Read(*this);
	hyperlist.insert(hypert, -1);
	}
	break;
	}
	case 6:
	{
	ReadBlock(_hwpInfo.back_info.reserved1, 8);
	_hwpInfo.back_info.luminance = Read4b();
	_hwpInfo.back_info.contrast = Read4b();
	_hwpInfo.back_info.effect = sal::static_int_cast<char>(Read1b());
	ReadBlock(_hwpInfo.back_info.reserved2, 7);
	ReadBlock(_hwpInfo.back_info.filename, 260);
	ReadBlock(_hwpInfo.back_info.color, 3);
	unsigned short nFlag = sal::static_int_cast<unsigned short>(Read2b());
	_hwpInfo.back_info.flag = nFlag >> 8 ;
	int nRange = Read4b();
	_hwpInfo.back_info.range = nRange >> 24;
	ReadBlock(_hwpInfo.back_info.reserved3, 27);
	_hwpInfo.back_info.size = Read4b();

	_hwpInfo.back_info.data = new char[(unsigned int)_hwpInfo.back_info.size];
	ReadBlock(_hwpInfo.back_info.data, _hwpInfo.back_info.size);

	if( _hwpInfo.back_info.size > 0 )
	_hwpInfo.back_info.type = 2;
	else if( _hwpInfo.back_info.filename[0] )
	_hwpInfo.back_info.type = 1;
	else
	_hwpInfo.back_info.type = 0;


	_hwpInfo.back_info.isset = true;

	break;
	}
	case FILETAG_PRESENTATION:
	case FILETAG_PREVIEW_IMAGE:
	case FILETAG_PREVIEW_TEXT:
	default:
	SkipBlock(size);
	}
	}
	// return false;
	}


	ColumnDef *HWPFile::GetColumnDef(int num)
	{
	ColumnInfo *cinfo = columnlist.find(num);
	if( cinfo )
	return cinfo->coldef;
	else
	return 0;
	}
	/* @return 인덱스는 1부터 시작한다. */
	int HWPFile::GetPageMasterNum(int page)
	{
	LinkedListIterator<ColumnInfo> it(&columnlist);
	//os: unused
	//ColumnInfo *prev = 0;
	ColumnInfo *now = 0;
	int i;

	for( i = 1 ; it.current() ; it++, i++){
	now = it.current();
	if( page < now->start_page )
	return i-1;
	}
	return i-1;
	}

	HyperText *HWPFile::GetHyperText()
	{
	return hyperlist.find(currenthyper++);
	}

	EmPicture HWPFile::GetEmPicture(Picture pic)
	{
	char *name = pic->picinfo.picembed.embname;

	name[0] = 'H';
	name[1] = 'W';
	name[2] = 'P';

	LinkedListIterator < EmPicture > it(&emblist);
	for (; it.current(); it++)
	if (strcmp(name, it.current()->name) == 0)
	return it.current();
	return 0;
	}

	EmPicture HWPFile::GetEmPictureByName(char name)
	{
	name[0] = 'H';
	name[1] = 'W';
	name[2] = 'P';

	LinkedListIterator < EmPicture > it(&emblist);
	for (; it.current(); it++)
	if (strcmp(name, it.current()->name) == 0)
	return it.current();
	return 0;
	}


	void HWPFile::AddBox(FBox * box)
	{
	// LATER if we don't use box->next(),
	// AddBox() and GetBoxHead() are useless;
	if (blist.count())
	{
	box->prev = blist.last();
	box->prev->next = box;
	}
	else
	box->prev = 0;
	blist.insert(box, -1);
	}


	ParaShape *HWPFile::getParaShape(int index)
	{
	return pslist.find(index);
	}


	CharShape *HWPFile::getCharShape(int index)
	{
	return cslist.find(index);
	}


	FBoxStyle *HWPFile::getFBoxStyle(int index)
	{
	return fbslist.find(index);
	}

	DateCode *HWPFile::getDateCode(int index)
	{
	return datecodes.find(index);
	}

	HeaderFooter *HWPFile::getHeaderFooter(int index)
	{
	return headerfooters.find(index);
	}

	ShowPageNum *HWPFile::getPageNumber(int index)
	{
	return pagenumbers.find(index);
	}

	Table *HWPFile::getTable(int index)
	{
	return tables.find(index);
	}

	void HWPFile::AddParaShape(ParaShape * pshape)
	{
	int nscount = 0;
	for(int j = 0 ; j < MAXTABS-1 ; j++)
	{
	if( j > 0 && pshape->tabs[j].position == 0 )
	break;
	if( pshape->tabs[0].position == 0 ){
	if( pshape->tabs[j].type \|\| pshape->tabs[j].dot_continue \|\|
	(pshape->tabs[j].position != 1000 *j) )
	nscount = j;
	}
	else{
	if( pshape->tabs[j].type \|\| pshape->tabs[j].dot_continue \|\|
	(pshape->tabs[j].position != 1000 * (j + 1)) )
	nscount = j;
	}
	}
	if( nscount )
	pshape->tabs[MAXTABS-1].type = sal::static_int_cast<char>(nscount);
	int value = compareParaShape(pshape);
	if( value == 0 \|\| nscount )
	{
	pshape->index = ++pcount;
	pslist.insert(pshape, -1);
	}
	else
	pshape->index = value;
	}


	void HWPFile::AddCharShape(CharShape * cshape)
	{
	int value = compareCharShape(cshape);
	if( value == 0 )
	{
	cshape->index = ++ccount;
	cslist.insert(cshape, -1);
	}
	else
	cshape->index = value;
	}

	void HWPFile::AddColumnInfo()
	{
	ColumnInfo *cinfo = new ColumnInfo(m_nCurrentPage);
	columnlist.insert(cinfo, -1);
	setMaxSettedPage();
	}

	void HWPFile::SetColumnDef(ColumnDef *coldef)
	{
	ColumnInfo *cinfo = columnlist.last();
	if( cinfo->bIsSet )
	return;
	cinfo->coldef = coldef;
	cinfo->bIsSet = true;
	}

	void HWPFile::AddDateFormat(DateCode * hbox)
	{
	hbox->key = sal::static_int_cast<char>(++datecodecount);
	datecodes.insert(hbox, -1);
	}

	void HWPFile::AddPageNumber(ShowPageNum * hbox)
	{
	pagenumbers.insert(hbox, -1);
	}

	void HWPFile::AddHeaderFooter(HeaderFooter * hbox)
	{
	headerfooters.insert(hbox, -1);
	}

	void HWPFile::AddTable(Table * hbox)
	{
	tables.insert(hbox, -1);
	}

	void HWPFile::AddFBoxStyle(FBoxStyle * fbstyle)
	{
	fbslist.insert(fbstyle, -1);
	}

	int HWPFile::compareCharShape(CharShape *shape)
	{
	int count = cslist.count();
	if( count > 0 )
	{
	CharShape *cshape=0;
	for(int i = 0; i< count; i++)
	{
	cshape = cslist.find(i);

	if( shape->size == cshape->size &&
	shape->font[0] == cshape->font[0] &&
	shape->ratio[0] == cshape->ratio[0] &&
	shape->space[0] == cshape->space[0] &&
	shape->color[1] == cshape->color[1] &&
	shape->color[0] == cshape->color[0] &&
	shape->shade == cshape->shade &&
	shape->attr == cshape->attr )
	{
	return cshape->index;
	}
	}
	}
	return 0;
	}


	int HWPFile::compareParaShape(ParaShape *shape)
	{
	int count = pslist.count();
	if( count > 0 )
	{
	ParaShape *pshape=0;
	for(int i = 0; i< count; i++)
	{
	pshape = pslist.find(i);
	if( shape->left_margin == pshape->left_margin &&
	shape->right_margin == pshape->right_margin &&
	shape->pspacing_prev == pshape->pspacing_prev &&
	shape->pspacing_next == pshape->pspacing_next &&
	shape->indent == pshape->indent &&
	shape->lspacing == pshape->lspacing &&
	shape->arrange_type == pshape->arrange_type &&
	shape->outline == pshape->outline &&
	shape->pagebreak == pshape->pagebreak)
	{
	if( shape->cshape->size == pshape->cshape->size &&
	shape->cshape->font[0] == pshape->cshape->font[0] &&
	shape->cshape->ratio[0] == pshape->cshape->ratio[0] &&
	shape->cshape->space[0] == pshape->cshape->space[0] &&
	shape->cshape->color[1] == pshape->cshape->color[1] &&
	shape->cshape->color[0] == pshape->cshape->color[0] &&
	shape->cshape->shade == pshape->cshape->shade &&
	shape->cshape->attr == pshape->cshape->attr )
	{
	return pshape->index;
	}
	}
	}
	}
	return 0;
	}


	HWPFile *GetCurrentDoc(void)
	{
	return HWPFile::cur_doc;
	}


	HWPFile SetCurrentDoc(HWPFile hwpfp)
	{
	HWPFile *org = HWPFile::cur_doc;

	HWPFile::cur_doc = hwpfp;
	return org;
	}