| /************************************************************** |
| * |
| * 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; |
| } |