LCOV - code coverage report
Current view: top level - hwpfilter/source - hbox.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 10 305 3.3 %
Date: 2014-11-03 Functions: 4 42 9.5 %
Legend: Lines: hit not hit

          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 <ctype.h>
      23             : 
      24             : #include <osl/diagnose.h>
      25             : 
      26             : #include "hwpfile.h"
      27             : #include "hbox.h"
      28             : #include "hpara.h"
      29             : #include "hutil.h"
      30             : #include "htags.h"
      31             : #include "drawdef.h"
      32             : #include "hcode.h"
      33             : 
      34             : int HBox::boxCount = 0;
      35             : 
      36          70 : HBox::HBox(hchar hch)
      37             : {
      38          70 :     hh = hch;
      39          70 :     boxCount++;
      40          70 : }
      41             : 
      42             : 
      43         140 : HBox::~HBox()
      44             : {
      45          70 :     boxCount--;
      46         140 : }
      47             : 
      48             : 
      49         132 : int HBox::WSize(void)
      50             : {
      51             :     static const int wsize[32] =
      52             :     {
      53             :         1, 4, 4, 4, 4, 4, 4, 42,                  /* dateform */
      54             :         48, 4, 4, 4, 4, 1, 4, 4,                  /* hidden */
      55             :         4, 4, 4, 4, 4, 4, 12, 5,                  /* chcompose */
      56             :         3, 3, 123, 4, 32, 4, 2, 2
      57             :     };
      58             : 
      59         132 :     if (hh < 32)
      60           0 :         return wsize[hh];
      61             :     else
      62         132 :         return 1;
      63             : }
      64             : 
      65             : 
      66           0 : hchar_string HBox::GetString()
      67             : {
      68           0 :     hchar_string ret;
      69           0 :     ret.push_back(hh);
      70           0 :     return ret;
      71             : }
      72             : 
      73             : 
      74           0 : hunit HBox::Height(CharShape *csty)
      75             : {
      76           0 :     return( csty->size );
      77             : }
      78             : 
      79             : // skip block
      80           0 : SkipData::SkipData(hchar hch)
      81             :     : HBox(hch)
      82             :     , data_block_len(0)
      83             :     , dummy(0)
      84           0 :     , data_block(0)
      85             : {
      86           0 : }
      87             : 
      88           0 : SkipData::~SkipData(void)
      89             : {
      90           0 :     delete[]data_block;
      91           0 : }
      92             : 
      93             : 
      94             : // FieldCode [5]
      95           0 : FieldCode::FieldCode()
      96             :     : HBox(CH_FIELD)
      97             :     , location_info(0)
      98             :     , str1(NULL)
      99             :     , str2(NULL)
     100             :     , str3(NULL)
     101             :     , bin(NULL)
     102           0 :     , m_pDate(NULL)
     103             : {
     104           0 :     reserved1 = new char[4];
     105           0 :     reserved2 = new char[22];
     106           0 : }
     107             : 
     108           0 : FieldCode::~FieldCode(void)
     109             : {
     110           0 :     delete[] str1;
     111           0 :     delete[] str2;
     112           0 :     delete[] str3;
     113           0 :     delete[] bin;
     114           0 :     delete[] reserved1;
     115           0 :     delete[] reserved2;
     116           0 :     delete m_pDate;
     117           0 : }
     118             : 
     119             : // book mark(6)
     120           0 : Bookmark::Bookmark()
     121             :     : HBox(CH_BOOKMARK)
     122             :     , dummy(0)
     123           0 :     , type(0)
     124             : {
     125           0 : }
     126             : 
     127           0 : Bookmark::~Bookmark(void)
     128             : {
     129           0 : }
     130             : 
     131             : // date format(7)
     132           0 : DateFormat::DateFormat()
     133             :     : HBox(CH_DATE_FORM)
     134           0 :     , dummy(0)
     135             : {
     136           0 : }
     137             : 
     138             : // date code(8)
     139           0 : DateCode::DateCode()
     140             :     : HBox(CH_DATE_CODE)
     141             :     , dummy(0)
     142           0 :     , key(0)
     143             : {
     144           0 : }
     145             : 
     146             : #define _DATECODE_WEEK_DEFINES_
     147             : #include "datecode.h"
     148             : 
     149           0 : hchar_string DateCode::GetString()
     150             : {
     151           0 :     hchar_string ret;
     152             :     const hchar *fmt;
     153             :     int i, num;
     154             :     const char *form;
     155             :     char cbuf[256];
     156             :     bool is_pm, add_zero;
     157             : 
     158           0 :     add_zero = false;
     159           0 :     format[DATE_SIZE - 1] = 0;
     160           0 :     fmt = format[0] ? format : defaultform;
     161             : 
     162           0 :     for (; *fmt && ((int) ret.size() < DATE_SIZE); fmt++)
     163             :     {
     164           0 :         form = (add_zero) ? "%02d" : "%d";
     165             : 
     166           0 :         add_zero = false;
     167           0 :         is_pm = (date[HOUR] >= 12);
     168           0 :         *cbuf = 0;
     169           0 :         num = -1;
     170             : 
     171           0 :         switch (*fmt)
     172             :         {
     173             :         case '0':
     174           0 :             add_zero = true;
     175           0 :             break;
     176             :         case '1':
     177           0 :             num = date[YEAR];
     178           0 :             form = "%04d";
     179           0 :             break;
     180             :         case '!':
     181           0 :             num = date[YEAR] % 100;
     182           0 :             break;
     183             :         case '2':
     184           0 :             num = date[MONTH];
     185           0 :             break;
     186             :         case '@':
     187           0 :             memcpy(cbuf, eng_mon + (date[MONTH] - 1) * 3, 3);
     188           0 :             cbuf[3] = '.';
     189           0 :             cbuf[4] = 0;
     190           0 :                 break;
     191             :         case '*':
     192           0 :             strncat(cbuf, en_mon[date[MONTH] - 1], sizeof(cbuf) - strlen(cbuf) - 1);
     193           0 :             break;
     194             :         case '3':                             /* 'D' is day of korean */
     195           0 :             num = date[DAY];
     196           0 :             break;
     197             :         case '#':
     198           0 :             num = date[DAY];
     199           0 :             switch (date[DAY] % 10)
     200             :             {
     201             :             case 1:
     202           0 :                 form = "%dst";
     203           0 :                 break;
     204             :             case 2:
     205           0 :                 form = "%dnd";
     206           0 :                 break;
     207             :             case 3:
     208           0 :                 form = "%drd";
     209           0 :                 break;
     210             :             default:
     211           0 :                 form = "%dth";
     212           0 :                 break;
     213             :             }
     214           0 :             break;
     215             :         case '4':
     216           0 :             num = date[HOUR] - ((date[HOUR] > 12) ? 12 : 0);
     217           0 :             break;
     218             :         case '$':
     219           0 :             num = date[HOUR];
     220           0 :             break;
     221             :         case '5':
     222             :         case '%':
     223           0 :             num = date[MIN];
     224           0 :             break;
     225             :         case '6':
     226           0 :             ret.push_back(kor_week[date[WEEK]]);
     227           0 :             break;
     228             :         case '^':
     229           0 :             memcpy(cbuf, eng_week + date[WEEK] * 3, 3);
     230           0 :             cbuf[3] = '.';
     231           0 :             cbuf[4] = 0;
     232           0 :             break;
     233             :         case '_':
     234           0 :             strncat(cbuf, en_week[date[WEEK]], sizeof(cbuf) - strlen(cbuf) - 1);
     235           0 :             break;
     236             :         case '7':
     237           0 :             ret.push_back(0xB5A1);
     238           0 :             ret.push_back((is_pm) ? 0xD281 : 0xB8E5);
     239           0 :             break;
     240             :         case '&':
     241           0 :             strncat(cbuf, (is_pm) ? "p.m." : "a.m.", sizeof(cbuf) - strlen(cbuf) - 1);
     242           0 :             break;
     243             :         case '+':
     244           0 :             strncat(cbuf, (is_pm) ? "P.M." : "A.M.", sizeof(cbuf) - strlen(cbuf) - 1);
     245           0 :             break;
     246             :         case '8':                             // 2.5 feature
     247             :         case '9':
     248             : #if 0
     249             : // LATER
     250             :             mkcurfilename(cbuf, *fmt);
     251             :             for (i = 0; cbuf[i] != 0 && slen > 1; i++)
     252             :             {                                 //for hangle filename
     253             :                 if (cbuf[i] & 0x80 && cbuf[i + 1] != 0)
     254             :                 {
     255             :                     *d++ = (cbuf[i] << 8) | cbuf[i + 1];
     256             :                     i++;
     257             :                 }
     258             :                 else
     259             :                     *d++ = cbuf[i];
     260             :                 slen--;
     261             :             }
     262             : #endif
     263           0 :             cbuf[0] = 0;
     264           0 :             break;
     265             :         case '~':                             // 3.0b feature
     266           0 :             if (fmt[1] == 0)
     267           0 :                 break;
     268           0 :             fmt++;
     269           0 :             if (*fmt == '6')
     270             :             {
     271           0 :                 ret.push_back(china_week[date[WEEK]]);
     272           0 :                 break;
     273             :             }
     274           0 :             break;
     275             :         default:
     276           0 :             if (*fmt == '\\' && *++fmt == 0)
     277           0 :                 goto done;
     278           0 :             ret.push_back(*fmt);
     279             :         }
     280           0 :         if (num != -1)
     281           0 :             sprintf(cbuf, form, num);
     282           0 :         for (i = 0; 0 != cbuf[i]; i++)
     283             :         {
     284           0 :             ret.push_back(*(cbuf + i));
     285             :         }
     286             :     }
     287             :     done:
     288           0 :     return ret;
     289             : }
     290             : 
     291             : // tab(9)
     292           0 : Tab::Tab()
     293             :     : HBox(CH_TAB)
     294             :     , width(0)
     295             :     , leader(0)
     296           0 :     , dummy(0)
     297             : {
     298           0 : }
     299             : 
     300             : // floating box
     301           0 : FBox::FBox(hchar hch)
     302             :     : HBox(hch)
     303             :     , zorder(0)
     304             :     , option(0)
     305             :     , ctrl_ch(0)
     306             :     , box_xs(0)
     307             :     , box_ys(0)
     308             :     , cap_xs(0)
     309             :     , cap_ys(0)
     310             :     , xs(0)
     311             :     , ys(0)
     312             :     , cap_margin(0)
     313             :     , xpos_type(0)
     314             :     , ypos_type(0)
     315             :     , smart_linesp(0)
     316             :     , boundsy(0)
     317             :     , boundey(0)
     318             :     , boundx(0)
     319             :     , draw(0)
     320             :     , pgx(0)
     321             :     , pgy(0)
     322             :     , pgno(0)
     323             :     , showpg(0)
     324             :     , prev(NULL)
     325           0 :     , next(NULL)
     326             : {
     327           0 : }
     328             : 
     329           0 : FBox::~FBox()
     330             : {
     331           0 : }
     332             : 
     333             : // tbox(10) TABLE BOX MATH BUTTON HYPERTEXT
     334           0 : TxtBox::TxtBox()
     335             :     : FBox(CH_TEXT_BOX)
     336             :     , dummy(0)
     337             :     , dummy1(0)
     338             :     , cap_len(0)
     339             :     , next(0)
     340             :     , dummy2(0)
     341             :     , reserved1(0)
     342             :     , cap_pos(0)
     343             :     , num(0)
     344             :     , dummy3(0)
     345             :     , baseline(0)
     346             :     , type(0)
     347             :     , nCell(0)
     348             :     , protect(0)
     349             :     , cell(0)
     350             :     , m_pTable(NULL)
     351           0 :     , plists(NULL)
     352             : {
     353           0 :     reserved[0] = reserved[1] = 0;
     354           0 : }
     355             : 
     356           0 : TxtBox::~TxtBox(void)
     357             : {
     358           0 :     delete[]cell;
     359             : 
     360           0 :     for (int ii = 0; ii < nCell; ++ii)
     361             :     {
     362           0 :         std::list < HWPPara* >::iterator it = plists[ii].begin();
     363           0 :         for (; it != plists[ii].end(); ++it)
     364             :         {
     365           0 :             HWPPara* pPara = *it;
     366           0 :             delete pPara;
     367             :         }
     368             :     }
     369             : 
     370           0 :     std::list < HWPPara* >::iterator it = caption.begin();
     371           0 :     for (; it != caption.end(); ++it)
     372             :     {
     373           0 :         HWPPara* pPara = *it;
     374           0 :         delete pPara;
     375             :     }
     376             : 
     377           0 :     delete[]plists;
     378           0 : }
     379             : 
     380             : 
     381           0 : hunit TxtBox::Height(CharShape * csty)
     382             : {
     383           0 :     return (style.anchor_type == CHAR_ANCHOR) ? box_ys : csty->size;
     384             : }
     385             : 
     386             : 
     387             : // picture(11)
     388             : 
     389           0 : Picture::Picture()
     390             :     : FBox(CH_PICTURE)
     391             :     , dummy(0)
     392             :     , follow_block_size(0)
     393             :     , dummy1(0)
     394             :     , dummy2(0)
     395             :     , reserved1(0)
     396             :     , cap_pos(0)
     397             :     , num(0)
     398             :     , pictype(0)
     399             :     , follow(0)
     400           0 :     , ishyper(false)
     401             : {
     402           0 : }
     403             : 
     404           0 : Picture::~Picture(void)
     405             : {
     406           0 :     delete[]follow;
     407           0 :     if( pictype == PICTYPE_DRAW && picinfo.picdraw.hdo )
     408           0 :         delete (HWPDrawingObject *) picinfo.picdraw.hdo;
     409             : 
     410           0 :     std::list < HWPPara* >::iterator it = caption.begin();
     411           0 :     for (; it != caption.end(); ++it)
     412             :     {
     413           0 :         HWPPara* pPara = *it;
     414           0 :         delete pPara;
     415             :     }
     416           0 : }
     417             : 
     418             : 
     419           0 : int Picture::Type()
     420             : {
     421           0 :     return pictype;
     422             : }
     423             : 
     424             : 
     425           0 : hunit Picture::Height(CharShape * sty)
     426             : {
     427           0 :     return (style.anchor_type == CHAR_ANCHOR) ? box_ys : sty->size;
     428             : }
     429             : 
     430             : 
     431             : // line(14)
     432             : // hidden(15)
     433           0 : Hidden::~Hidden(void)
     434             : {
     435           0 :     std::list < HWPPara* >::iterator it = plist.begin();
     436           0 :     for (; it != plist.end(); ++it)
     437             :     {
     438           0 :         HWPPara* pPara = *it;
     439           0 :         delete pPara;
     440             :     }
     441           0 : }
     442             : 
     443             : 
     444             : // header/footer(16)
     445           0 : HeaderFooter::~HeaderFooter(void)
     446             : {
     447           0 :     std::list < HWPPara* >::iterator it = plist.begin();
     448           0 :     for (; it != plist.end(); ++it)
     449             :     {
     450           0 :         HWPPara* pPara = *it;
     451           0 :         delete pPara;
     452             :     }
     453           0 : }
     454             : 
     455             : 
     456             : // footnote(17)
     457           0 : Footnote::~Footnote(void)
     458             : {
     459           0 :     std::list < HWPPara* >::iterator it = plist.begin();
     460           0 :     for (; it != plist.end(); ++it)
     461             :     {
     462           0 :         HWPPara* pPara = *it;
     463           0 :         delete pPara;
     464             :     }
     465           0 : }
     466             : 
     467             : 
     468             : // auto number(18)
     469             : // new number(19)
     470             : // show page number (20)
     471             : // 홀수쪽시작/감추기 (21)
     472             : 
     473             : // mail merge(22)
     474           0 : hchar_string MailMerge::GetString()
     475             : {
     476           0 :     return hchar_string();
     477             : }
     478             : 
     479             : 
     480             : // character compositon(23)
     481             : // hyphen(24)
     482             : // toc mark(25)
     483             : // index mark(26)
     484             : // outline(28)
     485             : 
     486             : #define OL_HANGL_JASO   0
     487             : #define OL_HANGL_KANATA 1
     488             : 
     489           0 : static hchar olHanglJaso(int num, int type)
     490             : {
     491             :     static const unsigned char han_init[] =
     492             :         { 0x88, 0x90, 0x94, 0x9c, 0xa0, 0xa4, 0xac, 0xb4, 0xb8, 0xc0, 0xc4, 0xc8, 0xcc, 0xd0 };
     493             :     static const unsigned char jung[] = { 3, 5, 7, 11, 13, 19, 20, 26, 27, 29, 30 };
     494             :     static const unsigned char jung2[] = { 3, 7, 13, 20, 27, 29, 30 };
     495             : 
     496           0 :     hchar hh = 0;
     497             : 
     498           0 :     if (type == OL_HANGL_JASO)
     499             :     {
     500           0 :         num = num % (14 + (sizeof(jung) / sizeof(char)));
     501             : 
     502           0 :         if (num < 14)
     503           0 :             hh = (han_init[num] << 8) | 'A';
     504             :         else
     505           0 :             hh = (jung[num - 14] << 5) | 0x8401;
     506             :     }
     507             :     else
     508             :     {
     509           0 :         if (num < 14)
     510           0 :             hh = (han_init[num] << 8) | 'a';
     511             :         else
     512             :         {
     513           0 :             int j = (num / 14) % (sizeof(jung2) / sizeof(char));
     514             : 
     515           0 :             num = num % 14;
     516           0 :             hh = (han_init[num] << 8) | (jung2[j] << 5) | 1;
     517             :         }
     518             :     }
     519           0 :     return hh;
     520             : }
     521             : 
     522             : 
     523           0 : static const hchar *GetOutlineStyleChars(int style)
     524             : {
     525             :     static const hchar out_bul_style_entry[5][8] =      // extern
     526             :     {
     527             :         {                                         // 0 OLSTY_BULLET1
     528             :             0x2f18, 0x2f12, 0x2f08, 0x2f02, 0x2f06, 0x2f00, 0x2043, 0x0000
     529             :         },
     530             :         {                                         // 1
     531             :             0x2f18, 0x2f12, 0x2f06, 0x2f00, 0x2f36, 0x2f30, 0x2043, 0x0000
     532             :         },
     533             :         {                                         // 2
     534             :             0x2f26, 0x2f20, 0x2f06, 0x2f00, 0x2f16, 0x2f10, 0x2043, 0x0000
     535             :         },
     536             :         {                                         // 3
     537             :             0x2f18, 0x2f16, 0x2f12, 0x2f10, 0x2f06, 0x2f00, 0x2043, 0x0000
     538             :         },
     539             :         {
     540             :             0xAC61, 0xB677, 0xB861, 0xB8F7, 0xB781, 0x0000
     541             :         },
     542             :     };
     543           0 :     if (style >= OLSTY_BULLET1 && style <= OLSTY_BULLET5)
     544           0 :         return out_bul_style_entry[style - OLSTY_BULLET1];
     545           0 :     return NULL;
     546             : }
     547             : 
     548             : 
     549           0 : static void getOutlineNumStr(int style, int level, int num, hchar * hstr)
     550             : {
     551             :     enum
     552             :     {
     553             :         U_ROM = 0x01, L_ROM = 0x02, U_ENG = 0x04, L_ENG = 0x08,
     554             :         HAN = 0x10, NUM = 0x20, L_BR = 0x40, R_BR = 0x80
     555             :     };
     556             :     static const unsigned char type_tbl[][MAX_OUTLINE_LEVEL] =
     557             :     {
     558             :         {
     559             :             U_ROM, HAN, NUM, HAN | R_BR, L_BR | NUM | R_BR,
     560             :             L_BR | HAN | R_BR, L_ROM | R_BR
     561             :         },
     562             :         {
     563             :             U_ROM, U_ENG, NUM, L_ENG | R_BR, L_BR | NUM | R_BR,
     564             :             L_BR | L_ENG | R_BR, L_ROM | R_BR
     565             :         },
     566             :         {
     567             :             NUM, HAN, L_BR | NUM | R_BR, L_BR | HAN | R_BR, NUM |
     568             :             R_BR, HAN | R_BR, L_ENG
     569             :         }
     570             :     };
     571           0 :     char fmt = type_tbl[style - OLSTY_NUMSIG1][level];
     572             :     char buf[80], *ptr;
     573             : 
     574           0 :     if (num < 1)
     575           0 :         num = 1;
     576           0 :     if (fmt & L_BR)
     577           0 :         *hstr++ = '(';
     578           0 :     if (fmt & NUM)
     579             :     {
     580           0 :         sprintf(buf, "%d", num);
     581           0 :         str2hstr(buf, hstr);
     582           0 :         hstr += strlen(buf);
     583             :     }
     584           0 :     else if (fmt & (U_ROM | L_ROM))
     585             :     {
     586           0 :         num2roman(num, buf);
     587           0 :         if (fmt & U_ROM)
     588             :         {
     589           0 :             ptr = buf;
     590           0 :             while (*ptr)
     591             :             {
     592           0 :                 *ptr = sal::static_int_cast<char>(toupper(*ptr));
     593           0 :                 ptr++;
     594             :             }
     595             :         }
     596           0 :         str2hstr(buf, hstr);
     597           0 :         hstr += strlen(buf);
     598             :     }
     599             :     else
     600             :     {
     601           0 :         num = (num - 1) % 26;
     602           0 :         if (fmt & U_ENG)
     603           0 :             *hstr++ = sal::static_int_cast<hchar>('A' + num);
     604           0 :         else if (fmt & L_ENG)
     605           0 :             *hstr++ = sal::static_int_cast<hchar>('a' + num);
     606           0 :         else if (fmt & HAN)
     607           0 :             *hstr++ = olHanglJaso(num, OL_HANGL_KANATA);
     608             :     }
     609           0 :     *hstr++ = (fmt & R_BR) ? ')' : '.';
     610           0 :     *hstr = 0;
     611           0 : }
     612             : 
     613             : 
     614             : enum
     615             : { OUTLINE_ON, OUTLINE_NUM };
     616             : 
     617             : /*  level 은 0부터 시작. 즉 1.1.1. 의 레벨은 2이다.
     618             :     number는 값이 그대로 들어가 있다. 즉, 1.2.1에는 1,2,1이 들어가 있다.
     619             :     style 은 1부터 값이 들어가 있다. hbox.h에 정의된 데로..
     620             :  */
     621           0 : hchar_string Outline::GetUnicode() const
     622             : {
     623             :     const hchar *p;
     624             :      hchar buffer[255];
     625             : 
     626           0 :     buffer[0] = 0;
     627           0 :     if (kind == OUTLINE_NUM)
     628             :     {
     629             :         int levelnum;
     630           0 :         switch (shape)
     631             :         {
     632             :             case OLSTY_NUMS1:
     633             :             case OLSTY_NUMS2:
     634             :             {
     635             :                 char cur_num_str[10], buf[80];
     636             :                 int i;
     637             : 
     638           0 :                 buf[0] = 0;
     639           0 :                 for (i = 0; i <= level; i++)
     640             :                 {
     641           0 :                     levelnum = ((number[i] < 1) ? 1 : number[i]);
     642           0 :                     if (shape == OLSTY_NUMS2 && i && i == level)
     643           0 :                         sprintf(cur_num_str, "%d%c", levelnum, 0);
     644             :                     else
     645           0 :                         sprintf(cur_num_str, "%d%c", levelnum, '.');
     646           0 :                     strcat(buf, cur_num_str);
     647             :                 }
     648           0 :                 str2hstr(buf, buffer);
     649           0 :                 return hstr2ucsstr(buffer);
     650             :             }
     651             :             case OLSTY_NUMSIG1:
     652             :             case OLSTY_NUMSIG2:
     653             :             case OLSTY_NUMSIG3:
     654             :                 {
     655           0 :                 getOutlineNumStr(shape, level, number[level], buffer);
     656           0 :                 return hstr2ucsstr(buffer);
     657             :                 }
     658             :             case OLSTY_BULLET1:
     659             :             case OLSTY_BULLET2:
     660             :             case OLSTY_BULLET3:
     661             :             case OLSTY_BULLET4:
     662             :             case OLSTY_BULLET5:
     663             :                 {
     664           0 :                 p = GetOutlineStyleChars(shape);
     665           0 :                 buffer[0] = p[level];
     666           0 :                 buffer[1] = 0;
     667           0 :                      return hstr2ucsstr(buffer);
     668             :                 }
     669             :             case OLSTY_USER:
     670             :             case OLSTY_BULUSER:
     671             :                 {
     672             :                         char dest[80];
     673           0 :                     int l = 0;
     674           0 :                     int i = level;
     675           0 :                     if( deco[i][0] ){
     676           0 :                         buffer[l++] = deco[i][0];
     677             :                     }
     678             : /*  level 은 0부터 시작. 즉 1.1.1. 의 레벨은 2이다.
     679             :     number는 값이 그대로 들어가 있다. 즉, 1.2.1에는 1,2,1이 들어가 있다.
     680             :     style 은 1부터 값이 들어가 있다. hbox.h에 정의된 데로..
     681             :  */
     682           0 :                     switch( user_shape[i] )
     683             :                     {
     684             :                         case 0:
     685           0 :                             buffer[l++] = '1' + number[i] - 1;
     686           0 :                             break;
     687             :                         case 1: /* 대문자로마 */
     688             :                         case 2: /* 소문자로마 */
     689           0 :                             num2roman(number[i], dest);
     690           0 :                             if( user_shape[i] == 1 ){
     691           0 :                                 char *ptr = dest;
     692           0 :                                 while( *ptr )
     693             :                                 {
     694           0 :                                     *ptr = sal::static_int_cast<char>(toupper(*ptr));
     695           0 :                                     ptr++;
     696             :                                 }
     697             :                             }
     698           0 :                             str2hstr(dest, buffer + l);
     699           0 :                             l += strlen(dest);
     700           0 :                             break;
     701             :                         case 3:
     702           0 :                             buffer[l++] = 'A' + number[i] -1;
     703           0 :                             break;
     704             :                         case 4:
     705           0 :                             buffer[l++] = 'a' + number[i] -1;
     706           0 :                             break;
     707             :                         case 5:
     708           0 :                             buffer[l++] = olHanglJaso(number[i] -1, OL_HANGL_KANATA);
     709           0 :                             break;
     710             :                         case 6:
     711           0 :                             buffer[l++] = olHanglJaso(number[i] -1, OL_HANGL_JASO);
     712           0 :                             break;
     713             :                         case 7: /* 한자 숫자 : 일반 숫자로 표현 */
     714           0 :                             buffer[l++] = '1' + number[i] -1;
     715           0 :                             break;
     716             :                         case 8: /* 원숫자 */
     717           0 :                             buffer[l++] = 0x2e00 + number[i];
     718           0 :                             break;
     719             :                         case 9: /* 원 알파벳 소문자 */
     720           0 :                             buffer[l++] = 0x2c20 + number[i];
     721           0 :                             break;
     722             :                         case 10: /* 원 가나다 */
     723           0 :                             buffer[l++] = 0x2c50 + number[i] -1;
     724           0 :                             break;
     725             :                         case 11: /* 원 ㄱ ㄴ */
     726           0 :                             buffer[l++] = 0x2c40 + number[i] -1;
     727           0 :                             break;
     728             :                         case 12: /* 이어진 숫자. */
     729             :                         {
     730             :                              char cur_num_str[10],buf[80];
     731             :                              int j;
     732           0 :                              buf[0] = 0;
     733           0 :                              for (j = 0; j <= level; j++)
     734             :                              {
     735           0 :                                   levelnum = ((number[j] < 1) ? 1 : number[j]);
     736           0 :                                   if ((j && j == level) || (j == level && deco[i][1]))
     737           0 :                                         sprintf(cur_num_str, "%d%c", levelnum, 0);
     738             :                                   else
     739           0 :                                         sprintf(cur_num_str, "%d%c", levelnum, '.');
     740           0 :                                   strcat(buf, cur_num_str);
     741             :                              }
     742           0 :                              str2hstr(buf, buffer + l);
     743           0 :                              l += strlen(buf);
     744           0 :                             break;
     745             :                         }
     746             :                         default:
     747           0 :                             buffer[l++] = user_shape[i];
     748           0 :                             break;
     749             :                     }
     750           0 :                     if( deco[i][1] ){
     751           0 :                         buffer[l++] = deco[i][1];
     752             :                     }
     753           0 :                     buffer[l] = 0;
     754           0 :                     return hstr2ucsstr(buffer);
     755             :                 }
     756             :         }
     757             :     }
     758           0 :     return hstr2ucsstr(buffer);
     759             : }
     760             : 
     761             : 
     762             : /* 묶음 빈칸(30) */
     763             : /* 고정폭 빈칸(31) */
     764             : 
     765             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10