LCOV - code coverage report
Current view: top level - starmath/source - mathtype.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 203 2059 9.9 %
Date: 2014-11-03 Functions: 12 38 31.6 %
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             : 
      21             : #include <mathtype.hxx>
      22             : #include <osl/diagnose.h>
      23             : #include <sfx2/docfile.hxx>
      24             : 
      25          20 : void MathType::Init()
      26             : {
      27             :     //These are the default MathType sizes
      28          20 :     aSizeTable[0]=12;
      29          20 :     aSizeTable[1]=8;
      30          20 :     aSizeTable[2]=6;
      31          20 :     aSizeTable[3]=24;
      32          20 :     aSizeTable[4]=10;
      33          20 :     aSizeTable[5]=12;
      34          20 :     aSizeTable[6]=12;
      35             : 
      36             :     /*
      37             :     These are the default MathType italic/bold settings If mathtype is changed
      38             :     from its defaults, there is nothing we can do, as this information is not
      39             :     stored in the document
      40             :     */
      41          20 :     MathTypeFont aFont;
      42         240 :     for(sal_uInt8 i=1;i<=11;i++)
      43             :     {
      44         220 :         aFont.nTface = i+128;
      45         220 :         switch (i)
      46             :         {
      47             :             default:
      48         160 :                 aFont.nStyle=0;
      49         160 :                 break;
      50             :             case 3:
      51             :             case 4:
      52          40 :                 aFont.nStyle=1;
      53          40 :                 break;
      54             :             case 7:
      55          20 :                 aFont.nStyle=2;
      56          20 :                 break;
      57             :         }
      58         220 :         aUserStyles.insert(aFont);
      59             :     }
      60          20 : }
      61             : 
      62             : 
      63             : /*ToDo replace with table rather than switch, returns
      64             :  sal_True in the case that the char is just a char, and
      65             :  sal_False if the character is an operator which must not be
      66             :  placed inside the quote sequence designed to protect
      67             :  against being parsed as a keyword
      68             : 
      69             :  General solution required to force starmath to handle
      70             :  unicode math chars the way it handles its own math
      71             :  chars rathar than handle them as text as it will do
      72             :  for the default case below, i.e. incorrect spacing
      73             :  between math symbols and ordinary text e.g. 1=2 rather
      74             :  than 1 = 2
      75             :  */
      76          48 : bool MathType::LookupChar(sal_Unicode nChar,OUString &rRet,sal_uInt8 nVersion,
      77             :     sal_uInt8 nTypeFace)
      78             : {
      79          48 :     bool bRet=false;
      80          48 :     const char *pC = NULL;
      81          48 :     switch(nChar)
      82             :     {
      83             :         case 0x0000:
      84           0 :             pC = " none ";
      85           0 :             break;
      86             :         case 0x00ac:
      87           0 :             pC = " neg ";
      88           0 :             break;
      89             :         case 0x00b1:
      90           0 :             pC = " +- ";
      91           0 :             break;
      92             :         case '(':
      93           0 :             pC = " \\( ";
      94           0 :             break;
      95             :         case ')':
      96           0 :             pC = " \\) ";
      97           0 :             break;
      98             :         case '[':
      99           0 :             pC = " \\[ ";
     100           0 :             break;
     101             :         case ']':
     102           0 :             pC = " \\] ";
     103           0 :             break;
     104             :         case '.':
     105           0 :             pC = " \".\" ";
     106           0 :             break;
     107             :         case 0xae:
     108           0 :             if ((nVersion < 3) && (nTypeFace == 0x86))
     109           0 :                 pC = " rightarrow ";
     110             :             else
     111             :             {
     112           0 :                 rRet += OUString( nChar );
     113           0 :                 bRet=true;
     114             :             }
     115           0 :             break;
     116             :         case 0x00fb:
     117           0 :             if ((nVersion < 3) && (nTypeFace == 0x81))
     118           0 :                 nChar = 0xDF;
     119           0 :             rRet += OUString( nChar );
     120           0 :             bRet=true;
     121           0 :             break;
     122             :         case 'a':
     123           0 :             if ((nVersion < 3) && (nTypeFace == 0x84))
     124           0 :                 nChar = 0x3b1;
     125           0 :             rRet += OUString( nChar );
     126           0 :             bRet=true;
     127           0 :             break;
     128             :         case 'b':
     129           0 :             if ((nVersion < 3) && (nTypeFace == 0x84))
     130           0 :                 nChar = 0x3b2;
     131           0 :             rRet += OUString( nChar );
     132           0 :             bRet=true;
     133           0 :             break;
     134             :         case 'l':
     135           0 :             if ((nVersion < 3) && (nTypeFace == 0x84))
     136           0 :                 nChar = 0x3bb;
     137           0 :             rRet += OUString( nChar );
     138           0 :             bRet=true;
     139           0 :             break;
     140             :         case 'n':
     141           0 :             if ((nVersion < 3) && (nTypeFace == 0x84))
     142           0 :                 nChar = 0x3bd;
     143           0 :             rRet += OUString( nChar );
     144           0 :             bRet=true;
     145           0 :             break;
     146             :         case 'r':
     147           0 :             if ((nVersion < 3) && (nTypeFace == 0x84))
     148           0 :                 nChar = 0x3c1;
     149           0 :             rRet += OUString( nChar );
     150           0 :             bRet=true;
     151           0 :             break;
     152             :         case 'D':
     153           0 :             if ((nVersion < 3) && (nTypeFace == 0x84))
     154           0 :                 nChar = 0x394;
     155           0 :             rRet += OUString( nChar );
     156           0 :             bRet=true;
     157           0 :             break;
     158             :         case 0xa9:
     159           0 :             if ((nVersion < 3) && (nTypeFace == 0x82))
     160           0 :                 nChar = '\'';
     161           0 :             rRet += OUString( nChar );
     162           0 :             bRet=true;
     163           0 :             break;
     164             :         case 0x00f1:
     165           0 :             if ((nVersion < 3) && (nTypeFace == 0x86))
     166           0 :                 pC = " \\rangle ";
     167             :             else
     168             :             {
     169           0 :                 rRet += OUString( nChar );
     170           0 :                 bRet=true;
     171             :             }
     172           0 :             break;
     173             :         case 0x00a3:
     174           0 :             if ((nVersion < 3) && (nTypeFace == 0x86))
     175           0 :                 pC = " <= ";
     176             :             else
     177             :             {
     178           0 :                 rRet += OUString( nChar );
     179           0 :                 bRet=true;
     180             :             }
     181           0 :             break;
     182             :         case 0x00de:
     183           0 :             if ((nVersion < 3) && (nTypeFace == 0x86))
     184           0 :                 pC = " drarrow ";
     185             :             else
     186             :             {
     187           0 :                 rRet += OUString( nChar );
     188           0 :                 bRet=true;
     189             :             }
     190           0 :             break;
     191             :         case 0x0057:
     192           0 :             if ((nVersion < 3) && (nTypeFace == 0x85))
     193           0 :                 pC = " %OMEGA ";
     194             :             else
     195             :             {
     196           0 :                 rRet += OUString( nChar );
     197           0 :                 bRet=true;
     198             :             }
     199           0 :             break;
     200             :         case 0x007b:
     201           0 :             pC = " lbrace ";
     202           0 :             break;
     203             :         case 0x007c:
     204           0 :             pC = " \\lline ";
     205           0 :             break;
     206             :         case 0x007d:
     207           0 :             pC = " rbrace ";
     208           0 :             break;
     209             :         case 0x007e:
     210           0 :             pC = " \"~\" ";
     211           0 :             break;
     212             :         case 0x2224:
     213           0 :             pC = " ndivides ";
     214           0 :             break;
     215             :         case 0x2225:
     216           0 :             pC = " parallel ";
     217           0 :             break;
     218             :         case 0x00d7:
     219           0 :             if (nVersion < 3)
     220           0 :                 pC = " cdot ";
     221             :             else
     222           0 :                 pC = " times ";
     223           0 :             break;
     224             :         case 0x00f7:
     225           0 :             pC = " div ";
     226           0 :             break;
     227             :         case 0x019b:
     228           0 :             pC = " lambdabar ";
     229           0 :             break;
     230             :         case 0x2026:
     231           0 :             pC = " dotslow ";
     232           0 :             break;
     233             :         case 0x2022:
     234           0 :             pC = " cdot ";
     235           0 :             break;
     236             :         case 0x2102:
     237           0 :             pC = " setC ";
     238           0 :             break;
     239             :         case 0x210f:
     240           0 :             pC = " hbar ";
     241           0 :             break;
     242             :         case 0x2111:
     243           0 :             pC = " Im ";
     244           0 :             break;
     245             :         case 0x2115:
     246           0 :             pC = " setN ";
     247           0 :             break;
     248             :         case 0x2118:
     249           0 :             pC = " wp ";
     250           0 :             break;
     251             :         case 0x211a:
     252           0 :             pC = " setQ ";
     253           0 :             break;
     254             :         case 0x211c:
     255           0 :             pC = " Re ";
     256           0 :             break;
     257             :         case 0x211d:
     258           0 :             pC = " setR ";
     259           0 :             break;
     260             :         case 0x2124:
     261           0 :             pC = " setZ ";
     262           0 :             break;
     263             :         case 0x2135:
     264           0 :             pC = " aleph ";
     265           0 :             break;
     266             :         case 0x2190:
     267           0 :             pC = " leftarrow ";
     268           0 :             break;
     269             :         case 0x2191:
     270           0 :             pC = " uparrow ";
     271           0 :             break;
     272             :         case 0x2192:
     273           0 :             pC = " rightarrow ";
     274           0 :             break;
     275             :         case 0x0362:
     276           0 :             pC = " widevec ";
     277           0 :             break;
     278             :         case 0x2193:
     279           0 :             pC = " downarrow ";
     280           0 :             break;
     281             :         case 0x21d0:
     282           0 :             pC = " dlarrow ";
     283           0 :             break;
     284             :         case 0x21d2:
     285           0 :             pC = " drarrow ";
     286           0 :             break;
     287             :         case 0x21d4:
     288           0 :             pC = " dlrarrow ";
     289           0 :             break;
     290             :         case 0x2200:
     291           0 :             pC = " forall ";
     292           0 :             break;
     293             :         case 0x2202:
     294           0 :             pC = " partial ";
     295           0 :             break;
     296             :         case 0x2203:
     297           0 :             pC = " exists ";
     298           0 :             break;
     299             :         case 0x2204:
     300           0 :             pC = " notexists ";
     301           0 :             break;
     302             :         case 0x2205:
     303           0 :             pC = " emptyset ";
     304           0 :             break;
     305             :         case 0x2207:
     306           0 :             pC = " nabla ";
     307           0 :             break;
     308             :         case 0x2208:
     309           0 :             pC = " in ";
     310           0 :             break;
     311             :         case 0x2209:
     312           0 :             pC = " notin ";
     313           0 :             break;
     314             :         case 0x220d:
     315           0 :             pC = " owns ";
     316           0 :             break;
     317             :         case 0x220f:
     318           0 :             pC = " prod ";
     319           0 :             break;
     320             :         case 0x2210:
     321           0 :             pC = " coprod ";
     322           0 :             break;
     323             :         case 0x2211:
     324           0 :             pC = " sum ";
     325           0 :             break;
     326             :         case 0x2212:
     327           0 :             pC = " - ";
     328           0 :             break;
     329             :         case 0x2213:
     330           0 :             pC = " -+ ";
     331           0 :             break;
     332             :         case 0x2217:
     333           0 :             pC = " * ";
     334           0 :             break;
     335             :         case 0x2218:
     336           0 :             pC = " circ ";
     337           0 :             break;
     338             :         case 0x221d:
     339           0 :             pC = " prop ";
     340           0 :             break;
     341             :         case 0x221e:
     342           0 :             pC = " infinity ";
     343           0 :             break;
     344             :         case 0x2227:
     345           0 :             pC = " and ";
     346           0 :             break;
     347             :         case 0x2228:
     348           0 :             pC = " or ";
     349           0 :             break;
     350             :         case 0x2229:
     351           0 :             pC = " intersection ";
     352           0 :             break;
     353             :         case 0x222a:
     354           0 :             pC = " union ";
     355           0 :             break;
     356             :         case 0x222b:
     357           0 :             pC = " int ";
     358           0 :             break;
     359             :         case 0x222c:
     360           0 :             pC = " iint ";
     361           0 :             break;
     362             :         case 0x222d:
     363           0 :             pC = " iiint ";
     364           0 :             break;
     365             :         case 0x222e:
     366           0 :             pC = " lint ";
     367           0 :             break;
     368             :         case 0x222f:
     369           0 :             pC = " llint ";
     370           0 :             break;
     371             :         case 0x2230:
     372           0 :             pC = " lllint ";
     373           0 :             break;
     374             :         case 0x2245:
     375           0 :             pC = " simeq ";
     376           0 :             break;
     377             :         case 0x2248:
     378           0 :             pC = " approx ";
     379           0 :             break;
     380             :         case 0x2260:
     381           0 :             pC = " <> ";
     382           0 :             break;
     383             :         case 0x2261:
     384           0 :             pC = " equiv ";
     385           0 :             break;
     386             :         case 0x2264:
     387           0 :             pC = " <= ";
     388           0 :             break;
     389             :         case 0x2265:
     390           0 :             pC = " >= ";
     391           0 :             break;
     392             : 
     393             :         case 0x227A:
     394           0 :             pC = " prec ";
     395           0 :             break;
     396             :         case 0x227B:
     397           0 :             pC = " succ ";
     398           0 :             break;
     399             :         case 0x227C:
     400           0 :             pC = " preccurlyeq ";
     401           0 :             break;
     402             :         case 0x227D:
     403           0 :             pC = " succcurlyeq ";
     404           0 :             break;
     405             :         case 0x227E:
     406           0 :             pC = " precsim ";
     407           0 :             break;
     408             :         case 0x227F:
     409           0 :             pC = " succsim ";
     410           0 :             break;
     411             :         case 0x2280:
     412           0 :             pC = " nprec ";
     413           0 :             break;
     414             :         case 0x2281:
     415           0 :             pC = " nsucc ";
     416           0 :             break;
     417             : 
     418             :         case 0x2282:
     419           0 :             pC = " subset ";
     420           0 :             break;
     421             :         case 0x2283:
     422           0 :             pC = " supset ";
     423           0 :             break;
     424             :         case 0x2284:
     425           0 :             pC = " nsubset ";
     426           0 :             break;
     427             :         case 0x2285:
     428           0 :             pC = " nsupset ";
     429           0 :             break;
     430             :         case 0x2286:
     431           0 :             pC = " subseteq ";
     432           0 :             break;
     433             :         case 0x2287:
     434           0 :             pC = " supseteq ";
     435           0 :             break;
     436             :         case 0x2288:
     437           0 :             pC = " nsubseteq ";
     438           0 :             break;
     439             :         case 0x2289:
     440           0 :             pC = " nsupseteq ";
     441           0 :             break;
     442             :         case 0x22b2:
     443             :         case 0x22b3:
     444           0 :             rRet += " " + OUString( nChar ) + " ";
     445           0 :             break;
     446             :         case 0x22a5:
     447           0 :             pC = " ortho ";
     448           0 :             break;
     449             :         case 0x22c5:
     450           0 :             pC = " cdot ";
     451           0 :             break;
     452             :         case 0x22ee:
     453           0 :             pC = " dotsvert ";
     454           0 :             break;
     455             :         case 0x22ef:
     456           0 :             pC = " dotsaxis ";
     457           0 :             break;
     458             :         case 0x22f0:
     459           0 :             pC = " dotsup ";
     460           0 :             break;
     461             :         case 0x22f1:
     462           0 :             pC = " dotsdown ";
     463           0 :             break;
     464             :         case MS_LANGLE:
     465             :         case MS_LMATHANGLE:
     466           0 :             pC = " langle ";
     467           0 :             break;
     468             :         case MS_RANGLE:
     469             :         case MS_RMATHANGLE:
     470           0 :             pC = " rangle ";
     471           0 :             break;
     472             :         case 0x301a:
     473           0 :             pC = " ldbracket ";
     474           0 :             break;
     475             :         case 0x301b:
     476           0 :             pC = " rdbracket ";
     477           0 :             break;
     478             :         case 0xe083:
     479           0 :             rRet += "+";
     480           0 :             bRet=true;
     481           0 :             break;
     482             :         case '^':
     483             :         case 0xe091:
     484           0 :             pC = " widehat ";
     485           0 :             break;
     486             :         case 0xe096:
     487           0 :             pC = " widetilde ";
     488           0 :             break;
     489             :         case 0xe098:
     490           0 :             pC = " widevec ";
     491           0 :             break;
     492             :         case 0xE421:
     493           0 :             pC = " geslant ";
     494           0 :             break;
     495             :         case 0xE425:
     496           0 :             pC = " leslant ";
     497           0 :             break;
     498             :         case 0xeb01:    //no space
     499             :         case 0xeb08:    //normal space
     500           0 :             bRet=true;
     501           0 :             break;
     502             :         case 0xef04:    //tiny space
     503             :         case 0xef05:    //tiny space
     504             :         case 0xeb02:    //small space
     505             :         case 0xeb04:    //medium space
     506           0 :             rRet += "`";
     507           0 :             break;
     508             :         case 0xeb05:    //large space
     509           0 :             rRet += "~";
     510           0 :             break;
     511             :         case 0x3a9:
     512           0 :             pC = " %OMEGA ";
     513           0 :             break;
     514             :         default:
     515          48 :             rRet += OUString( nChar );
     516          48 :             bRet=true;
     517          48 :             break;
     518             :     }
     519          48 :     if (pC)
     520           0 :         rRet += OUString::createFromAscii( pC );
     521          48 :     return bRet;
     522             : }
     523             : 
     524           0 : void MathTypeFont::AppendStyleToText(OUString &rRet)
     525             : {
     526           0 :     const char *pC = NULL;
     527           0 :     switch (nStyle)
     528             :     {
     529             :         default:
     530             :         case 0:
     531           0 :             break;
     532             :         case 1:
     533           0 :             pC = " ital ";
     534           0 :             break;
     535             :         case 2:
     536           0 :             pC = " bold ";
     537           0 :             break;
     538             :         case 3:
     539           0 :             pC = " bold italic";
     540           0 :             break;
     541             :     }
     542           0 :     if (pC)
     543           0 :         rRet += OUString::createFromAscii( pC );
     544           0 : }
     545             : 
     546           0 : void MathType::TypeFaceToString(OUString &rTxt,sal_uInt8 nFace)
     547             : {
     548           0 :     MathTypeFont aFont(nFace);
     549           0 :     MathTypeFontSet::iterator aItr = aUserStyles.find(aFont);
     550           0 :     if (aItr != aUserStyles.end())
     551           0 :         aFont.nStyle = aItr->nStyle;
     552           0 :     aFont.AppendStyleToText(rTxt);
     553           0 : }
     554             : 
     555          20 : int MathType::Parse(SotStorage *pStor)
     556             : {
     557             :     SvStorageStreamRef xSrc = pStor->OpenSotStream(
     558             :         OUString("Equation Native"),
     559          20 :         STREAM_STD_READ | STREAM_NOCREATE);
     560          20 :     if ( (!xSrc.Is()) || (SVSTREAM_OK != xSrc->GetError()))
     561           0 :         return 0;
     562          20 :     pS = &xSrc;
     563          20 :     pS->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
     564             : 
     565          20 :     EQNOLEFILEHDR aHdr;
     566          20 :     aHdr.Read(pS);
     567          20 :     pS->ReadUChar( nVersion );
     568          20 :     pS->ReadUChar( nPlatform );
     569          20 :     pS->ReadUChar( nProduct );
     570          20 :     pS->ReadUChar( nProdVersion );
     571          20 :     pS->ReadUChar( nProdSubVersion );
     572             : 
     573          20 :     if (nVersion > 3)   // allow only supported versions of MathType to be parsed
     574           0 :         return 0;
     575             : 
     576             : #ifdef STANDALONE
     577             :     *pOut << "Format Version is " << int(nVersion) << endl;
     578             :     *pOut << "Generating Platform is " << (nPlatform ? "Windows"
     579             :         : "Mac") << endl;
     580             :     *pOut << "Generating Product is " << (nPlatform ? "Equation Editor"
     581             :         : "Equation Editor") << endl;
     582             :     *pOut << "Prod Version is " << int(nProdVersion) << "." <<
     583             :         int(nProdSubVersion) << endl << endl;
     584             : #endif
     585             : 
     586          20 :     int nRet = HandleRecords();
     587             :     //little crude hack to close occasionally open expressions
     588             :     //a sophisticated system to determine what expressions are
     589             :     //opened is required, but this is as much work as rewriting
     590             :     //starmaths internals.
     591          20 :     rRet += "{}";
     592             : 
     593             : #if OSL_DEBUG_LEVEL > 1
     594             : #   ifdef CAOLAN
     595             :     //sanity check
     596             : 
     597             :     //sigh, theres no point! MathType (in some bizarre subvarient) pads
     598             :     //the end of the formula with ENDs (0)'s
     599             :     sal_uLong nEnd = pS->Tell();
     600             :     OSL_ENSURE(nEnd == pS->Seek(STREAM_SEEK_TO_END),
     601             :         "Possibly unfully parsed formula");
     602             : #   endif
     603             : #endif
     604          20 :     return nRet;
     605             : }
     606             : 
     607          48 : static void lcl_PrependDummyTerm(OUString &rRet, sal_Int32 &rTextStart)
     608             : {
     609         144 :     if ((rTextStart < rRet.getLength()) &&
     610          48 :         (rRet[rTextStart] == '=') &&
     611           0 :         ((rTextStart == 0) || (rRet[ rTextStart-1 ] == '{'))
     612             :        )
     613             :     {
     614           0 :         rRet = rRet.replaceAt(rTextStart,0," {}");
     615           0 :         rTextStart+=3;
     616             :     }
     617          48 : }
     618             : 
     619          20 : static void lcl_AppendDummyTerm(OUString &rRet)
     620             : {
     621          20 :     bool bOk=false;
     622          20 :     for(int nI=rRet.getLength()-1;nI >= 0; nI--)
     623             :     {
     624          20 :         sal_Int32 nIdx = sal::static_int_cast< sal_Int32 >(nI);
     625          20 :         sal_Unicode nChar = rRet[nIdx];
     626          20 :         if (nChar == ' ')
     627           0 :             continue;
     628          20 :         if (rRet[nIdx] != '{')
     629          20 :             bOk=true;
     630          20 :         break;
     631             :     }
     632          20 :     if (!bOk)   //No term, use dummy
     633           0 :         rRet += " {}";
     634          20 : }
     635             : 
     636           0 : void MathType::HandleNudge()
     637             : {
     638             :     sal_uInt8 nXNudge;
     639           0 :     pS->ReadUChar( nXNudge );
     640             :     sal_uInt8 nYNudge;
     641           0 :     pS->ReadUChar( nYNudge );
     642           0 :     if (nXNudge == 128 && nYNudge == 128)
     643             :     {
     644             :         sal_uInt16 nXLongNudge;
     645             :         sal_uInt16 nYLongNudge;
     646           0 :         pS->ReadUInt16( nXLongNudge );
     647           0 :         pS->ReadUInt16( nYLongNudge );
     648             :     }
     649           0 : }
     650             : /*Fabously complicated as many tokens have to be reordered and generally
     651             :  *moved around from mathtypes paradigm to starmaths.*/
     652          80 : int MathType::HandleRecords(int nLevel,sal_uInt8 nSelector,
     653             :     sal_uInt8 nVariation, int nMatrixRows,int nMatrixCols)
     654             : {
     655             :     sal_uInt8 nTag,nRecord;
     656             :     sal_uInt8 nTabType,nTabStops;
     657             :     sal_uInt16 nTabOffset;
     658          80 :     int i,nRet=1,newline=0;
     659          80 :     bool bSilent=false;
     660          80 :     int nPart=0;
     661         160 :     OUString sPush,sMainTerm;
     662          80 :     int nSetSize=0,nSetAlign=0;
     663          80 :     int nCurRow=0,nCurCol=0;
     664          80 :     bool bOpenString=false;
     665          80 :     sal_Int32 nTextStart = 0;
     666          80 :     sal_Int32 nSubSupStartPos = 0;
     667          80 :     sal_Int32 nLastTemplateBracket=-1;
     668             : 
     669         248 :     do
     670             :     {
     671         248 :         nTag = 0;
     672         248 :         pS->ReadUChar( nTag );
     673         248 :         nRecord = nTag&0x0F;
     674             : 
     675             :         /*MathType strings can of course include words which
     676             :          *are StarMath keywords, the simplest solution is
     677             :          to escape strings of greater than len 1 with double
     678             :          quotes to avoid scanning the TokenTable for matches
     679             : 
     680             :          Unfortunately it may turn out that the string gets
     681             :          split during the handling of a character emblishment
     682             :          so this special case must be handled in the
     683             :          character handler case 2:
     684             :          */
     685         248 :         if ((nRecord == CHAR) && (!bIsSilent) && (!bOpenString))
     686             :         {
     687          40 :             bOpenString=true;
     688          40 :             nTextStart = rRet.getLength();
     689             :         }
     690         208 :         else if ((nRecord != CHAR) && (bOpenString))
     691             :         {
     692          40 :             bOpenString=false;
     693          40 :             if ((rRet.getLength() - nTextStart) > 1)
     694             :             {
     695           0 :                 OUString aStr;
     696           0 :                 TypeFaceToString(aStr,nTypeFace);
     697           0 :                 aStr += "\"";
     698           0 :                 rRet = rRet.replaceAt(nTextStart,0,aStr);
     699           0 :                 rRet += "\"";
     700             :             }
     701          40 :             else if (nRecord == END && !rRet.isEmpty())
     702             :             {
     703          20 :                 sal_Unicode cChar = 0;
     704          20 :                 sal_Int32 nI = rRet.getLength()-1;
     705          40 :                 while (nI && ((cChar = rRet[nI]) == ' '))
     706           0 :                     --nI;
     707          20 :                 if ((cChar == '=') || (cChar == '+') || (cChar == '-'))
     708           0 :                     rRet += "{}";
     709             :             }
     710             :         }
     711             : 
     712         248 :         switch(nRecord)
     713             :         {
     714             :             case LINE:
     715             :                 {
     716          60 :                     if (xfLMOVE(nTag))
     717           0 :                         HandleNudge();
     718             : 
     719          60 :                     if (newline>0)
     720           0 :                         rRet += "\nnewline\n";
     721          60 :                     if (!(xfNULL(nTag)))
     722             :                     {
     723          40 :                         switch (nSelector)
     724             :                         {
     725             :                         case 0x0:
     726           0 :                             if (nVariation==0)
     727           0 :                                 rRet += " langle ";
     728           0 :                             else if (nVariation==1)
     729           0 :                                 rRet += " \\langle ";
     730           0 :                             break;
     731             :                         case 0x1:
     732           0 :                             if (nVariation==0)
     733           0 :                                 rRet += " left (";
     734           0 :                             else if (nVariation==1)
     735           0 :                                 rRet += "\\(";
     736           0 :                             break;
     737             :                         case 0x2:
     738           0 :                             if ((nVariation==0) || (nVariation==1))
     739           0 :                                 rRet += " left lbrace ";
     740             :                             else
     741           0 :                                 rRet += " left none ";
     742           0 :                             break;
     743             :                         case 0x3:
     744           0 :                             if (nVariation==0)
     745           0 :                                 rRet += " left [";
     746           0 :                             else if (nVariation==1)
     747           0 :                                 rRet += "\\[";
     748           0 :                             break;
     749             :                         case 0x8:
     750             :                         case 0xb:
     751           0 :                             rRet += " \\[";
     752           0 :                             break;
     753             :                         case 0x4:
     754           0 :                             if (nVariation==0)
     755           0 :                                 rRet += " lline ";
     756           0 :                             else if (nVariation==1)
     757           0 :                                 rRet += " \\lline ";
     758           0 :                             break;
     759             :                         case 0x5:
     760           0 :                             if (nVariation==0)
     761           0 :                                 rRet += " ldline ";
     762           0 :                             else if (nVariation==1)
     763           0 :                                 rRet += " \\ldline ";
     764           0 :                             break;
     765             :                         case 0x6:
     766           0 :                             if (nVariation == 0 || nVariation == 1)
     767           0 :                                 rRet += " left lfloor ";
     768           0 :                             else if (nVariation==1)
     769           0 :                                 rRet += " left none ";
     770           0 :                             break;
     771             :                         case 0x7:
     772           0 :                             if (nVariation==0)
     773           0 :                                 rRet += " lceil ";
     774           0 :                             else if (nVariation==1)
     775           0 :                                 rRet += " \\lceil ";
     776           0 :                             break;
     777             :                         case 0x9:
     778             :                         case 0xa:
     779           0 :                             rRet += " \\]";
     780           0 :                             break;
     781             :                         case 0xc:
     782           0 :                             rRet += " \\(";
     783           0 :                             break;
     784             :                         case 0xd:
     785           0 :                             if (nPart == 0)
     786             :                             {
     787           0 :                                 if (nVariation == 0)
     788           0 :                                     rRet += " sqrt";
     789             :                                 else
     790             :                                 {
     791           0 :                                     rRet += " nroot";
     792           0 :                                     sPush = rRet;
     793           0 :                                     rRet = OUString();
     794             :                                 }
     795             :                             }
     796           0 :                             rRet += " {";
     797           0 :                             break;
     798             :                         case 0xe:
     799           0 :                             if (nPart == 0)
     800           0 :                                 rRet += " { ";
     801             : 
     802             : 
     803           0 :                             if (nPart == 1)
     804           0 :                                 rRet += " over ";
     805           0 :                             rRet += " {";
     806           0 :                             break;
     807             :                         case 0xf:
     808          20 :                             nSubSupStartPos = rRet.getLength();
     809          40 :                             if ((nVariation == 0) ||
     810          20 :                                     ((nVariation == 2) && (nPart==1)))
     811             :                             {
     812           0 :                                 lcl_AppendDummyTerm(rRet);
     813           0 :                                 rRet += " rSup";
     814             :                             }
     815          20 :                             else if ((nVariation == 1) ||
     816           0 :                                     ((nVariation == 2) && (nPart==0)))
     817             :                             {
     818          20 :                                 lcl_AppendDummyTerm(rRet);
     819          20 :                                 rRet += " rSub";
     820             :                             }
     821          20 :                             rRet += " {";
     822          20 :                             break;
     823             :                         case 0x10:
     824           0 :                             if (nVariation == 0)
     825           0 :                                 rRet += " {underline ";
     826           0 :                             else if (nVariation == 1)
     827           0 :                                 rRet += " {underline underline ";
     828           0 :                             rRet += " {";
     829           0 :                             break;
     830             :                         case 0x11:
     831           0 :                             if (nVariation == 0)
     832           0 :                                 rRet += " {overline ";
     833           0 :                             else if (nVariation == 1)
     834           0 :                                 rRet += " {overline overline ";
     835           0 :                             rRet += " {";
     836           0 :                             break;
     837             :                         case 0x12:
     838           0 :                             if (nPart == 0)
     839             :                             {
     840           0 :                                 if (nVariation == 0)
     841           0 :                                     rRet += " widevec ";//left arrow above
     842           0 :                                 else if (nVariation == 1)
     843           0 :                                     rRet += " widevec ";//left arrow below
     844           0 :                                 rRet += " {";
     845             :                             }
     846           0 :                             break;
     847             :                         case 0x13:
     848           0 :                             if (nPart == 0)
     849             :                             {
     850           0 :                                 if (nVariation == 0)
     851           0 :                                     rRet += " widevec ";//right arrow above
     852           0 :                                 else if (nVariation == 1)
     853           0 :                                     rRet += " widevec ";//right arrow below
     854           0 :                                 rRet += " {";
     855             :                             }
     856           0 :                             break;
     857             :                         case 0x14:
     858           0 :                             if (nPart == 0)
     859             :                             {
     860           0 :                                 if (nVariation == 0)
     861           0 :                                     rRet += " widevec ";//double arrow above
     862           0 :                                 else if (nVariation == 1)
     863           0 :                                     rRet += " widevec ";//double arrow below
     864           0 :                                 rRet += " {";
     865             :                             }
     866           0 :                             break;
     867             :                         case 0x15:
     868           0 :                             if (nPart == 0)
     869             :                             {
     870           0 :                                 if ((nVariation == 3) || (nVariation == 4))
     871           0 :                                     rRet += " lInt";
     872             :                                 else
     873           0 :                                     rRet += " Int";
     874           0 :                                 if ( (nVariation != 0) && (nVariation != 3))
     875             :                                 {
     876           0 :                                     sPush = rRet;
     877           0 :                                     rRet = OUString();
     878             :                                 }
     879             :                             }
     880           0 :                             if (((nVariation == 1) ||
     881           0 :                                     (nVariation == 4)) && (nPart==1))
     882           0 :                                 rRet += " rSub";
     883           0 :                             else if ((nVariation == 2) && (nPart==2))
     884           0 :                                 rRet += " rSup";
     885           0 :                             else if ((nVariation == 2) && (nPart==1))
     886           0 :                                 rRet += " rSub";
     887           0 :                             rRet += " {";
     888           0 :                             break;
     889             :                         case 0x16:
     890           0 :                             if (nPart == 0)
     891             :                             {
     892           0 :                                 if ((nVariation == 2) || (nVariation == 3))
     893           0 :                                     rRet += " llInt";
     894             :                                 else
     895           0 :                                     rRet += " iInt";
     896           0 :                                 if ( (nVariation != 0) && (nVariation != 2))
     897             :                                 {
     898           0 :                                     sPush = rRet;
     899           0 :                                     rRet = OUString();
     900             :                                 }
     901             :                             }
     902           0 :                             if (((nVariation == 1) ||
     903           0 :                                     (nVariation == 3)) && (nPart==1))
     904           0 :                                 rRet += " rSub";
     905           0 :                             rRet += " {";
     906           0 :                             break;
     907             :                         case 0x17:
     908           0 :                             if (nPart == 0)
     909             :                             {
     910           0 :                                 if ((nVariation == 2) || (nVariation == 3))
     911           0 :                                     rRet += " lllInt";
     912             :                                 else
     913           0 :                                     rRet += " iiInt";
     914           0 :                                 if ( (nVariation != 0) && (nVariation != 2))
     915             :                                 {
     916           0 :                                     sPush = rRet;
     917           0 :                                     rRet = OUString();
     918             :                                 }
     919             :                             }
     920           0 :                             if (((nVariation == 1) ||
     921           0 :                                     (nVariation == 3)) && (nPart==1))
     922           0 :                                 rRet += " rSub";
     923           0 :                             rRet += " {";
     924           0 :                             break;
     925             :                         case 0x18:
     926           0 :                             if (nPart == 0)
     927             :                             {
     928           0 :                                 if (nVariation == 2)
     929           0 :                                     rRet += " lInt";
     930             :                                 else
     931           0 :                                     rRet += " Int";
     932           0 :                                 sPush = rRet;
     933           0 :                                 rRet = OUString();
     934             :                             }
     935           0 :                             if (((nVariation == 1) ||
     936           0 :                                     (nVariation == 2)) && (nPart==1))
     937           0 :                                 rRet += " cSub";
     938           0 :                             else if ((nVariation == 0) && (nPart==2))
     939           0 :                                 rRet += " cSup";
     940           0 :                             else if ((nVariation == 0) && (nPart==1))
     941           0 :                                 rRet += " cSub";
     942           0 :                             rRet += " {";
     943           0 :                             break;
     944             :                         case 0x19:
     945           0 :                             if (nPart == 0)
     946             :                             {
     947           0 :                                 if (nVariation == 0)
     948           0 :                                     rRet += " llInt";
     949             :                                 else
     950           0 :                                     rRet += " iInt";
     951           0 :                                 sPush = rRet;
     952           0 :                                 rRet = OUString();
     953             :                             }
     954           0 :                             if (nPart==1)
     955           0 :                                 rRet += " cSub";
     956           0 :                             rRet += " {";
     957           0 :                             break;
     958             :                         case 0x1a:
     959           0 :                             if (nPart == 0)
     960             :                             {
     961           0 :                                 if (nVariation == 0)
     962           0 :                                     rRet += " lllInt";
     963             :                                 else
     964           0 :                                     rRet += " iiInt";
     965           0 :                                 sPush = rRet;
     966           0 :                                 rRet = OUString();
     967             :                             }
     968           0 :                             if (nPart==1)
     969           0 :                                 rRet += " cSub";
     970           0 :                             rRet += " {";
     971           0 :                             break;
     972             :                         case 0x1b:
     973             :                         case 0x1c:
     974           0 :                             rRet += " {";
     975           0 :                             break;
     976             :                         case 0x1d:
     977           0 :                             if (nPart == 0)
     978             :                             {
     979           0 :                                 rRet += " Sum";
     980           0 :                                 if (nVariation != 2)
     981             :                                 {
     982           0 :                                     sPush = rRet;
     983           0 :                                     rRet = OUString();
     984             :                                 }
     985             :                             }
     986           0 :                             if ((nVariation == 0) && (nPart==1))
     987           0 :                                 rRet += " cSub";
     988           0 :                             else if ((nVariation == 1) && (nPart==2))
     989           0 :                                 rRet += " cSup";
     990           0 :                             else if ((nVariation == 1) && (nPart==1))
     991           0 :                                 rRet += " cSub";
     992           0 :                             rRet += " {";
     993           0 :                             break;
     994             :                         case 0x1e:
     995           0 :                             if (nPart == 0)
     996             :                             {
     997           0 :                                 rRet += " Sum";
     998           0 :                                 sPush = rRet;
     999           0 :                                 rRet = OUString();
    1000             :                             }
    1001           0 :                             if ((nVariation == 0) && (nPart==1))
    1002           0 :                                 rRet += " rSub";
    1003           0 :                             else if ((nVariation == 1) && (nPart==2))
    1004           0 :                                 rRet += " rSup";
    1005           0 :                             else if ((nVariation == 1) && (nPart==1))
    1006           0 :                                 rRet += " rSub";
    1007           0 :                             rRet += " {";
    1008           0 :                             break;
    1009             :                         case 0x1f:
    1010           0 :                             if (nPart == 0)
    1011             :                             {
    1012           0 :                                 rRet += " Prod";
    1013           0 :                                 if (nVariation != 2)
    1014             :                                 {
    1015           0 :                                     sPush = rRet;
    1016           0 :                                     rRet = OUString();
    1017             :                                 }
    1018             :                             }
    1019           0 :                             if ((nVariation == 0) && (nPart==1))
    1020           0 :                                 rRet += " cSub";
    1021           0 :                             else if ((nVariation == 1) && (nPart==2))
    1022           0 :                                 rRet += " cSup";
    1023           0 :                             else if ((nVariation == 1) && (nPart==1))
    1024           0 :                                 rRet += " cSub";
    1025           0 :                             rRet += " {";
    1026           0 :                             break;
    1027             :                         case 0x20:
    1028           0 :                             if (nPart == 0)
    1029             :                             {
    1030           0 :                                 rRet += " Prod";
    1031           0 :                                 sPush = rRet;
    1032           0 :                                 rRet = OUString();
    1033             :                             }
    1034           0 :                             if ((nVariation == 0) && (nPart==1))
    1035           0 :                                 rRet += " rSub";
    1036           0 :                             else if ((nVariation == 1) && (nPart==2))
    1037           0 :                                 rRet += " rSup";
    1038           0 :                             else if ((nVariation == 1) && (nPart==1))
    1039           0 :                                 rRet += " rSub";
    1040           0 :                             rRet += " {";
    1041           0 :                             break;
    1042             :                         case 0x21:
    1043           0 :                             if (nPart == 0)
    1044             :                             {
    1045           0 :                                 rRet += " coProd";
    1046           0 :                                 if (nVariation != 2)
    1047             :                                 {
    1048           0 :                                     sPush = rRet;
    1049           0 :                                     rRet = OUString();
    1050             :                                 }
    1051             :                             }
    1052           0 :                             if ((nVariation == 0) && (nPart==1))
    1053           0 :                                 rRet += " cSub";
    1054           0 :                             else if ((nVariation == 1) && (nPart==2))
    1055           0 :                                 rRet += " cSup";
    1056           0 :                             else if ((nVariation == 1) && (nPart==1))
    1057           0 :                                 rRet += " cSub";
    1058           0 :                             rRet += " {";
    1059           0 :                             break;
    1060             :                         case 0x22:
    1061           0 :                             if (nPart == 0)
    1062             :                             {
    1063           0 :                                 rRet += " coProd";
    1064           0 :                                 sPush = rRet;
    1065           0 :                                 rRet = OUString();
    1066             :                             }
    1067           0 :                             if ((nVariation == 0) && (nPart==1))
    1068           0 :                                 rRet += " rSub";
    1069           0 :                             else if ((nVariation == 1) && (nPart==2))
    1070           0 :                                 rRet += " rSup";
    1071           0 :                             else if ((nVariation == 1) && (nPart==1))
    1072           0 :                                 rRet += " rSub";
    1073           0 :                             rRet += " {";
    1074           0 :                             break;
    1075             :                         case 0x23:
    1076           0 :                             if (nPart == 0)
    1077             :                             {
    1078           0 :                                 rRet += " union"; //union
    1079           0 :                                 if (nVariation != 2)
    1080             :                                 {
    1081           0 :                                     sPush = rRet;
    1082           0 :                                     rRet = OUString();
    1083             :                                 }
    1084             :                             }
    1085           0 :                             if ((nVariation == 0) && (nPart==1))
    1086           0 :                                 rRet += " cSub";
    1087           0 :                             else if ((nVariation == 1) && (nPart==2))
    1088           0 :                                 rRet += " cSup";
    1089           0 :                             else if ((nVariation == 1) && (nPart==1))
    1090           0 :                                 rRet += " cSub";
    1091           0 :                             rRet += " {";
    1092           0 :                             break;
    1093             :                         case 0x24:
    1094           0 :                             if (nPart == 0)
    1095             :                             {
    1096           0 :                                 rRet += " union"; //union
    1097           0 :                                 sPush = rRet;
    1098           0 :                                 rRet = OUString();
    1099             :                             }
    1100           0 :                             if ((nVariation == 0) && (nPart==1))
    1101           0 :                                 rRet += " rSub";
    1102           0 :                             else if ((nVariation == 1) && (nPart==2))
    1103           0 :                                 rRet += " rSup";
    1104           0 :                             else if ((nVariation == 1) && (nPart==1))
    1105           0 :                                 rRet += " rSub";
    1106           0 :                             rRet += " {";
    1107           0 :                             break;
    1108             :                         case 0x25:
    1109           0 :                             if (nPart == 0)
    1110             :                             {
    1111           0 :                                 rRet += " intersect"; //intersect
    1112           0 :                                 if (nVariation != 2)
    1113             :                                 {
    1114           0 :                                     sPush = rRet;
    1115           0 :                                     rRet = OUString();
    1116             :                                 }
    1117             :                             }
    1118           0 :                             if ((nVariation == 0) && (nPart==1))
    1119           0 :                                 rRet += " cSub";
    1120           0 :                             else if ((nVariation == 1) && (nPart==2))
    1121           0 :                                 rRet += " cSup";
    1122           0 :                             else if ((nVariation == 1) && (nPart==1))
    1123           0 :                                 rRet += " cSub";
    1124           0 :                             rRet += " {";
    1125           0 :                             break;
    1126             :                         case 0x26:
    1127           0 :                             if (nPart == 0)
    1128             :                             {
    1129           0 :                                 rRet += " intersect"; //intersect
    1130           0 :                                 sPush = rRet;
    1131           0 :                                 rRet = OUString();
    1132             :                             }
    1133           0 :                             if ((nVariation == 0) && (nPart==1))
    1134           0 :                                 rRet += " rSub";
    1135           0 :                             else if ((nVariation == 1) && (nPart==2))
    1136           0 :                                 rRet += " rSup";
    1137           0 :                             else if ((nVariation == 1) && (nPart==1))
    1138           0 :                                 rRet += " rSub";
    1139           0 :                             rRet += " {";
    1140           0 :                             break;
    1141             :                         case 0x27:
    1142           0 :                             if ((nVariation == 0) && (nPart==1))
    1143           0 :                                 rRet += " cSup";
    1144           0 :                             else if ((nVariation == 1) && (nPart==1))
    1145           0 :                                 rRet += " cSub";
    1146           0 :                             else if ((nVariation == 2) && (nPart==1))
    1147           0 :                                 rRet += " cSub";
    1148           0 :                             else if ((nVariation == 2) && (nPart==2))
    1149           0 :                                 rRet += " cSup";
    1150           0 :                             rRet += " {";
    1151           0 :                             break;
    1152             :                         case 0x28:
    1153           0 :                             if (nVariation == 0)
    1154             :                             {
    1155           0 :                                 if (nPart == 0)
    1156             :                                 {
    1157           0 :                                     sPush = rRet;
    1158           0 :                                     rRet = OUString();
    1159             :                                 }
    1160             :                             }
    1161           0 :                             rRet += " {";
    1162           0 :                             if (nVariation == 0)
    1163             :                             {
    1164           0 :                                 if (nPart == 1)
    1165           0 :                                     rRet += "alignr ";
    1166             :                             }
    1167           0 :                             if (nPart == 0)
    1168           0 :                                 rRet += "\\lline ";
    1169           0 :                             if (nVariation == 1)
    1170           0 :                                 rRet += "overline ";
    1171           0 :                             break;
    1172             :                         case 0x29:
    1173           0 :                             rRet += " {";
    1174           0 :                             break;
    1175             :                         case 0x2a:
    1176           0 :                             if (nPart == 0)
    1177             :                             {
    1178           0 :                                 sPush = rRet;
    1179           0 :                                 rRet = OUString();
    1180             :                             }
    1181           0 :                             if ((nVariation == 0) && (nPart==0))
    1182           0 :                                 rRet += " rSup";
    1183           0 :                             else if ((nVariation == 2) && (nPart==1))
    1184           0 :                                 rRet += " rSup";
    1185           0 :                             else if ((nVariation == 1) && (nPart==0))
    1186           0 :                                 rRet += " rSub";
    1187           0 :                             else if ((nVariation == 2) && (nPart==0))
    1188           0 :                                 rRet += " rSub";
    1189           0 :                             rRet += " {";
    1190           0 :                             break;
    1191             :                         case 0x2b:
    1192           0 :                             if (nPart == 0)
    1193             :                             {
    1194           0 :                                 sPush = rRet;
    1195           0 :                                 rRet = OUString();
    1196             :                             }
    1197           0 :                             if ((nVariation == 0) && (nPart==0))
    1198           0 :                                 rRet += " cSup";
    1199           0 :                             else if ((nVariation == 2) && (nPart==1))
    1200           0 :                                 rRet += " cSup";
    1201           0 :                             else if ((nVariation == 1) && (nPart==0))
    1202           0 :                                 rRet += " cSub";
    1203           0 :                             else if ((nVariation == 2) && (nPart==0))
    1204           0 :                                 rRet += " cSub";
    1205           0 :                             rRet += " {";
    1206           0 :                             break;
    1207             :                         case 0x2c:
    1208           0 :                             if (nPart == 0)
    1209           0 :                                 rRet += "\"\"";
    1210           0 :                             if ((nVariation == 0)
    1211           0 :                                     || ((nVariation == 2) && (nPart==1)))
    1212           0 :                                 rRet += " lSup";
    1213           0 :                             else if ((nVariation == 1)
    1214           0 :                                     || ((nVariation == 2) && (nPart==0)))
    1215           0 :                                 rRet += " lSub";
    1216           0 :                             rRet += " {";
    1217           0 :                             break;
    1218             :                         case 0x2d:
    1219           0 :                             if (nVariation==0)
    1220             :                             {
    1221           0 :                                 if (nPart == 0)
    1222           0 :                                     rRet += " langle ";
    1223             :                             }
    1224           0 :                             else if (nVariation==1)
    1225             :                             {
    1226           0 :                                 rRet += " \\langle ";
    1227           0 :                                 newline--;
    1228             :                             }
    1229           0 :                             else if (nVariation==2)
    1230             :                             {
    1231           0 :                                 rRet += " \\lline ";
    1232           0 :                                 newline--;
    1233             :                             }
    1234           0 :                             break;
    1235             :                         case 0x2e:
    1236           0 :                             if (nVariation == 0)
    1237           0 :                                 rRet += " widevec ";//left below
    1238           0 :                             else if (nVariation == 1)
    1239           0 :                                 rRet += " widevec ";//right below
    1240           0 :                             else if (nVariation == 2)
    1241           0 :                                 rRet += " widevec ";//double headed below
    1242           0 :                             rRet += " {";
    1243           0 :                             break;
    1244             :                         case 0x2f:
    1245           0 :                             if (nVariation == 0)
    1246           0 :                                 rRet += " widevec ";//left above
    1247           0 :                             else if (nVariation == 1)
    1248           0 :                                 rRet += " widevec ";//right above
    1249           0 :                             else if (nVariation == 2)
    1250           0 :                                 rRet += " widevec ";//double headed above
    1251           0 :                             rRet += " {";
    1252           0 :                             break;
    1253             :                         default:
    1254          20 :                             break;
    1255             :                         }
    1256          40 :                         sal_Int16 nOldCurSize=nCurSize;
    1257          40 :                         sal_Int32 nSizeStartPos = rRet.getLength();
    1258          40 :                         HandleSize(nLSize,nDSize,nSetSize);
    1259          40 :                         nRet = HandleRecords(nLevel+1);
    1260         120 :                         while (nSetSize)
    1261             :                         {
    1262          40 :                             bool bOk=false;
    1263          40 :                             sal_Int32 nI = rRet.lastIndexOf('{');
    1264          40 :                             if (nI != -1)
    1265             :                             {
    1266          40 :                                 for(nI=nI+1;nI<rRet.getLength();nI++)
    1267          40 :                                     if (rRet[nI] != ' ')
    1268             :                                     {
    1269          40 :                                         bOk=true;
    1270          40 :                                         break;
    1271             :                                     }
    1272             :                             }
    1273             :                             else
    1274           0 :                                 bOk=true;
    1275             : 
    1276          40 :                             if (bOk)
    1277          40 :                                 rRet += "} ";
    1278             :                             else
    1279           0 :                                 rRet = rRet.replaceAt( nSizeStartPos, rRet.getLength(), "" );
    1280          40 :                             nSetSize--;
    1281          40 :                             nCurSize=nOldCurSize;
    1282             :                         }
    1283             : 
    1284             : 
    1285             :                         HandleMatrixSeparator(nMatrixRows,nMatrixCols,
    1286          40 :                             nCurCol,nCurRow);
    1287             : 
    1288          40 :                         switch (nSelector)
    1289             :                         {
    1290             :                         case 0x0:
    1291           0 :                             if (nVariation==0)
    1292           0 :                                 rRet += " rangle ";
    1293           0 :                             else if (nVariation==2)
    1294           0 :                                 rRet += " \\rangle ";
    1295           0 :                             break;
    1296             :                         case 0x1:
    1297           0 :                             if (nVariation==0)
    1298           0 :                                 rRet += " right )";
    1299           0 :                             else if (nVariation==2)
    1300           0 :                                 rRet += "\\)";
    1301           0 :                             break;
    1302             :                         case 0x2:
    1303           0 :                             if ((nVariation==0) || (nVariation==2))
    1304           0 :                                 rRet += " right rbrace ";
    1305             :                             else
    1306           0 :                                 rRet += " right none ";
    1307           0 :                             break;
    1308             :                         case 0x3:
    1309           0 :                             if (nVariation==0)
    1310           0 :                                 rRet += " right ]";
    1311           0 :                             else if (nVariation==2)
    1312           0 :                                 rRet += "\\]";
    1313           0 :                             break;
    1314             :                         case 0x4:
    1315           0 :                             if (nVariation==0)
    1316           0 :                                 rRet += " rline ";
    1317           0 :                             else if (nVariation==2)
    1318           0 :                                 rRet += " \\rline ";
    1319           0 :                             break;
    1320             :                         case 0x5:
    1321           0 :                             if (nVariation==0)
    1322           0 :                                 rRet += " rdline ";
    1323           0 :                             else if (nVariation==2)
    1324           0 :                                 rRet += " \\rdline ";
    1325           0 :                             break;
    1326             :                         case 0x6:
    1327           0 :                             if (nVariation == 0 || nVariation == 2)
    1328           0 :                                 rRet += " right rfloor ";
    1329           0 :                             else if (nVariation==2)
    1330           0 :                                 rRet += " right none ";
    1331           0 :                             break;
    1332             :                         case 0x7:
    1333           0 :                             if (nVariation==0)
    1334           0 :                                 rRet += " rceil ";
    1335           0 :                             else if (nVariation==2)
    1336           0 :                                 rRet += " \\rceil ";
    1337           0 :                             break;
    1338             :                         case 0x8:
    1339             :                         case 0xa:
    1340           0 :                             rRet += "\\[";
    1341           0 :                             break;
    1342             :                         case 0x9:
    1343             :                         case 0xc:
    1344           0 :                             rRet += "\\]";
    1345           0 :                             break;
    1346             :                         case 0xd:
    1347           0 :                             rRet += "} ";
    1348           0 :                             if (nVariation == 1)
    1349             :                             {
    1350           0 :                                 if (nPart == 0)
    1351             :                                 {
    1352           0 :                                     newline--;
    1353           0 :                                     sMainTerm = rRet;
    1354           0 :                                     rRet = OUString();
    1355             :                                 }
    1356             :                                 else
    1357             :                                 {
    1358           0 :                                     sPush += rRet;
    1359           0 :                                     rRet = sPush;
    1360           0 :                                     rRet += sMainTerm;
    1361             :                                 }
    1362             :                             }
    1363             :                             else
    1364             :                             {
    1365           0 :                                 if (nPart == 0)
    1366           0 :                                     newline--;
    1367             :                             }
    1368           0 :                             nPart++;
    1369           0 :                             break;
    1370             :                         case 0xb:
    1371           0 :                             rRet += "\\)";
    1372           0 :                             break;
    1373             :                         case 0xe:
    1374           0 :                             rRet += "} ";
    1375           0 :                             if (nPart == 0)
    1376           0 :                                 newline--;
    1377             :                             else
    1378           0 :                                 rRet += "} ";
    1379           0 :                             nPart++;
    1380           0 :                             break;
    1381             :                         case 0xf:
    1382             :                             {
    1383          40 :                             if ((nPart == 0) &&
    1384          40 :                                     ((nVariation == 2) || (nVariation == 1)))
    1385          20 :                                 newline--;
    1386             : 
    1387          20 :                             bool bOk=false;
    1388          20 :                             sal_Int32 nI = rRet.lastIndexOf('{');
    1389          20 :                             if (nI != -1)
    1390             :                             {
    1391          20 :                                 for(nI=nI+1;nI<rRet.getLength();nI++)
    1392          20 :                                     if (rRet[nI] != ' ')
    1393             :                                     {
    1394          20 :                                         bOk=true;
    1395          20 :                                         break;
    1396             :                                     }
    1397             :                             }
    1398             :                             else
    1399           0 :                                 bOk=true;
    1400             : 
    1401          20 :                             if (bOk)
    1402          20 :                                 rRet += "} ";
    1403             :                             else
    1404           0 :                                 rRet = rRet.replaceAt(nSubSupStartPos, rRet.getLength(), "");
    1405          20 :                             nPart++;
    1406             :                             }
    1407          20 :                             break;
    1408             :                         case 0x2c:
    1409           0 :                             if ((nPart == 0) &&
    1410           0 :                                     ((nVariation == 2) || (nVariation == 1)))
    1411           0 :                                 newline--;
    1412           0 :                             rRet += "} ";
    1413           0 :                             nPart++;
    1414           0 :                             break;
    1415             :                         case 0x2e:
    1416             :                         case 0x2f:
    1417           0 :                             rRet += "} ";
    1418           0 :                             break;
    1419             :                         case 0x10:
    1420             :                         case 0x11:
    1421           0 :                             rRet += "}} ";
    1422           0 :                             break;
    1423             :                         case 0x12:
    1424             :                         case 0x13:
    1425             :                         case 0x14:
    1426           0 :                             if (nPart == 0)
    1427             :                             {
    1428           0 :                                 newline--;
    1429           0 :                                 rRet += "} ";
    1430             :                             }
    1431           0 :                             nPart++;
    1432           0 :                             break;
    1433             :                         case 0x1b:
    1434           0 :                             rRet += "} ";
    1435           0 :                             if (nPart == 0)
    1436             :                             {
    1437           0 :                                 newline--;
    1438           0 :                                 rRet += "overbrace";
    1439             :                             }
    1440           0 :                             nPart++;
    1441           0 :                             break;
    1442             :                         case 0x1c:
    1443           0 :                             rRet += "} ";
    1444           0 :                             if (nPart == 0)
    1445             :                             {
    1446           0 :                                 newline--;
    1447           0 :                                 rRet += "underbrace";
    1448             :                             }
    1449           0 :                             nPart++;
    1450           0 :                             break;
    1451             :                         case 0x27:
    1452           0 :                             if (nPart==0)
    1453           0 :                                 newline--;
    1454           0 :                             else if ((nPart==1) &&
    1455           0 :                                     ((nVariation == 2) || (nVariation == 1)))
    1456           0 :                                 newline--;
    1457           0 :                             rRet += "} ";
    1458           0 :                             nPart++;
    1459           0 :                             break;
    1460             :                         case 0x28:
    1461           0 :                             rRet += "} ";
    1462           0 :                             if (nVariation == 0)
    1463             :                             {
    1464           0 :                                 if (nPart == 0)
    1465             :                                 {
    1466           0 :                                     sMainTerm = rRet;
    1467           0 :                                     rRet = OUString();
    1468             :                                 }
    1469             :                                 else
    1470             :                                 {
    1471           0 :                                     sPush += rRet;
    1472           0 :                                     rRet = sPush;
    1473           0 :                                     rRet += " over ";
    1474           0 :                                     rRet += sMainTerm;
    1475             :                                 }
    1476             :                             }
    1477           0 :                             if (nPart == 0)
    1478           0 :                                 newline--;
    1479           0 :                             nPart++;
    1480           0 :                             break;
    1481             :                         case 0x29:
    1482           0 :                             rRet += "} ";
    1483           0 :                             if (nPart == 0)
    1484             :                             {
    1485           0 :                                 newline--;
    1486           0 :                                 switch (nVariation)
    1487             :                                 {
    1488             :                                 case 1:
    1489           0 :                                     rRet += "slash";
    1490           0 :                                     break;
    1491             :                                 default:
    1492           0 :                                     rRet += "wideslash";
    1493           0 :                                     break;
    1494             :                                 }
    1495             :                             }
    1496           0 :                             nPart++;
    1497           0 :                             break;
    1498             :                         case 0x1d:
    1499             :                         case 0x1e:
    1500             :                         case 0x1f:
    1501             :                         case 0x20:
    1502             :                         case 0x21:
    1503             :                         case 0x22:
    1504             :                         case 0x23:
    1505             :                         case 0x24:
    1506             :                         case 0x25:
    1507             :                         case 0x26:
    1508           0 :                             rRet += "} ";
    1509           0 :                             if (nPart == 0)
    1510             :                             {
    1511           0 :                                 if (nVariation != 2)
    1512             :                                 {
    1513           0 :                                     sMainTerm = rRet;
    1514           0 :                                     rRet = OUString();
    1515             :                                 }
    1516           0 :                                 newline--;
    1517             :                             }
    1518           0 :                             else if ((nPart == 1) && (nVariation == 0))
    1519             :                             {
    1520           0 :                                 sPush += rRet;
    1521           0 :                                 rRet = sPush;
    1522           0 :                                 rRet += sMainTerm;
    1523           0 :                                 newline--;
    1524             :                             }
    1525           0 :                             else if ((nPart == 1) && (nVariation == 1))
    1526           0 :                                 newline--;
    1527           0 :                             else if ((nPart == 2) && (nVariation == 1))
    1528             :                             {
    1529           0 :                                 sPush += rRet;
    1530           0 :                                 rRet = sPush;
    1531           0 :                                 rRet += sMainTerm;
    1532           0 :                                 newline--;
    1533             :                             }
    1534           0 :                             nPart++;
    1535           0 :                             break;
    1536             :                         case 0x15:
    1537           0 :                             rRet += "} ";
    1538           0 :                             if (nPart == 0)
    1539             :                             {
    1540           0 :                                 if ((nVariation != 0) && (nVariation != 3))
    1541             :                                 {
    1542           0 :                                     sMainTerm = rRet;
    1543           0 :                                     rRet = OUString();
    1544             :                                 }
    1545           0 :                                 newline--;
    1546             :                             }
    1547           0 :                             else if ((nPart == 1) &&
    1548           0 :                                     ((nVariation == 1) || (nVariation==4)))
    1549             :                             {
    1550           0 :                                 sPush += rRet;
    1551           0 :                                 rRet = sPush;
    1552           0 :                                 rRet += sMainTerm;
    1553           0 :                                 newline--;
    1554             :                             }
    1555           0 :                             else if ((nPart == 1) && (nVariation == 2))
    1556           0 :                                 newline--;
    1557           0 :                             else if ((nPart == 2) && (nVariation == 2))
    1558             :                             {
    1559           0 :                                 sPush += rRet;
    1560           0 :                                 rRet = sPush;
    1561           0 :                                 rRet += sMainTerm;
    1562           0 :                                 newline--;
    1563             :                             }
    1564           0 :                             nPart++;
    1565           0 :                             break;
    1566             :                         case 0x16:
    1567             :                         case 0x17:
    1568           0 :                             rRet += "} ";
    1569           0 :                             if (nPart == 0)
    1570             :                             {
    1571           0 :                                 if ((nVariation != 0) && (nVariation != 2))
    1572             :                                 {
    1573           0 :                                     sMainTerm = rRet;
    1574           0 :                                     rRet = OUString();
    1575             :                                 }
    1576           0 :                                 newline--;
    1577             :                             }
    1578           0 :                             else if ((nPart == 1) &&
    1579           0 :                                     ((nVariation == 1) || (nVariation==3)))
    1580             :                             {
    1581           0 :                                 sPush += rRet;
    1582           0 :                                 rRet = sPush;
    1583           0 :                                 rRet += sMainTerm;
    1584           0 :                                 newline--;
    1585             :                             }
    1586           0 :                             nPart++;
    1587           0 :                             break;
    1588             :                         case 0x18:
    1589           0 :                             rRet += "} ";
    1590           0 :                             if (nPart == 0)
    1591             :                             {
    1592           0 :                                 sMainTerm = rRet;
    1593           0 :                                 rRet = OUString();
    1594           0 :                                 newline--;
    1595             :                             }
    1596           0 :                             else if ((nPart == 1) &&
    1597           0 :                                     ((nVariation == 1) || (nVariation==2)))
    1598             :                             {
    1599           0 :                                 sPush += rRet;
    1600           0 :                                 rRet = sPush;
    1601           0 :                                 rRet += sMainTerm;
    1602           0 :                                 newline--;
    1603             :                             }
    1604           0 :                             else if ((nPart == 1) && (nVariation == 0))
    1605           0 :                                 newline--;
    1606           0 :                             else if ((nPart == 2) && (nVariation == 0))
    1607             :                             {
    1608           0 :                                 sPush += rRet;
    1609           0 :                                 rRet = sPush;
    1610           0 :                                 rRet += sMainTerm;
    1611           0 :                                 newline--;
    1612             :                             }
    1613           0 :                             nPart++;
    1614           0 :                             break;
    1615             :                         case 0x19:
    1616             :                         case 0x1a:
    1617           0 :                             rRet += "} ";
    1618           0 :                             if (nPart == 0)
    1619             :                             {
    1620           0 :                                 sMainTerm = rRet;
    1621           0 :                                 rRet = OUString();
    1622           0 :                                 newline--;
    1623             :                             }
    1624           0 :                             else if (nPart == 1)
    1625             :                             {
    1626           0 :                                 sPush += rRet;
    1627           0 :                                 rRet = sPush;
    1628           0 :                                 rRet += sMainTerm;
    1629           0 :                                 newline--;
    1630             :                             }
    1631           0 :                             nPart++;
    1632           0 :                             break;
    1633             :                         case 0x2a:
    1634             :                         case 0x2b:
    1635           0 :                             rRet += "} ";
    1636             : 
    1637           0 :                             if ((nPart == 0) &&
    1638           0 :                                     ((nVariation == 0) || (nVariation == 1)))
    1639             :                             {
    1640           0 :                                 sMainTerm = rRet;
    1641           0 :                                 rRet = OUString();
    1642           0 :                                 newline--;
    1643             :                             }
    1644           0 :                             else if ((nPart == 0) && (nVariation == 2))
    1645           0 :                                 newline--;
    1646           0 :                             else if ((nPart == 1) && (nVariation == 2))
    1647             :                             {
    1648           0 :                                 sMainTerm = rRet;
    1649           0 :                                 rRet = OUString();
    1650           0 :                                 newline--;
    1651             :                             }
    1652           0 :                             else if ((nPart == 2) || ((((nPart == 1) &&
    1653           0 :                                     (nVariation == 0)) || (nVariation == 1))))
    1654             :                             {
    1655           0 :                                 sPush+=rRet;
    1656           0 :                                 rRet = sPush;
    1657           0 :                                 rRet += sMainTerm;
    1658             :                             }
    1659           0 :                             nPart++;
    1660           0 :                             break;
    1661             :                         case 0x2d:
    1662           0 :                             if (nVariation==0)
    1663             :                             {
    1664           0 :                                 if (nPart == 0)
    1665             :                                 {
    1666           0 :                                     newline--; //there is another term to arrive
    1667           0 :                                     rRet += " mline ";
    1668             :                                 }
    1669             :                                 else
    1670           0 :                                     rRet += " rangle ";
    1671             :                             }
    1672           0 :                             else if (nVariation==1)
    1673           0 :                                 rRet += " \\lline ";
    1674           0 :                             else if (nVariation==2)
    1675           0 :                                 rRet += " \\rangle ";
    1676           0 :                             nPart++;
    1677           0 :                             break;
    1678             :                         default:
    1679          20 :                             break;
    1680             :                         }
    1681          40 :                         bSilent = true; //Skip the optional brackets and/or
    1682             :                                         //symbols that follow some of these
    1683             :                                         //records. Foo Data.
    1684             : 
    1685             :                         /*In matrices and piles we cannot separate equation
    1686             :                          *lines with the newline keyword*/
    1687          40 :                         if (nMatrixCols==0)
    1688          40 :                             newline++;
    1689             :                     }
    1690             :                 }
    1691          60 :                 break;
    1692             :             case CHAR:
    1693          48 :                 if (xfLMOVE(nTag))
    1694           0 :                     HandleNudge();
    1695             :                 nRet = HandleChar(nTextStart,nSetSize,nLevel,nTag,nSelector,
    1696          48 :                     nVariation,bSilent);
    1697          48 :                  break;
    1698             :             case TMPL:
    1699          20 :                 if (xfLMOVE(nTag))
    1700           0 :                     HandleNudge();
    1701             :                 nRet = HandleTemplate(nLevel,nSelector,nVariation,
    1702          20 :                     nLastTemplateBracket);
    1703          20 :                 break;
    1704             :             case PILE:
    1705           0 :                 if (xfLMOVE(nTag))
    1706           0 :                     HandleNudge();
    1707           0 :                 nRet = HandlePile(nSetAlign,nLevel,nSelector,nVariation);
    1708           0 :                 HandleMatrixSeparator(nMatrixRows,nMatrixCols,nCurCol,nCurRow);
    1709           0 :                 break;
    1710             :             case MATRIX:
    1711           0 :                 if (xfLMOVE(nTag))
    1712           0 :                     HandleNudge();
    1713           0 :                 nRet = HandleMatrix(nLevel,nSelector,nVariation);
    1714           0 :                 HandleMatrixSeparator(nMatrixRows,nMatrixCols,nCurCol,nCurRow);
    1715           0 :                 break;
    1716             :             case EMBEL:
    1717           0 :                 if (xfLMOVE(nTag))
    1718           0 :                     HandleNudge();
    1719           0 :                 HandleEmblishments();
    1720           0 :                 break;
    1721             :             case RULER:
    1722           0 :                 pS->ReadUChar( nTabStops );
    1723           0 :                 for (i=0;i<nTabStops;i++)
    1724             :                 {
    1725           0 :                     pS->ReadUChar( nTabType );
    1726           0 :                     pS->ReadUInt16( nTabOffset );
    1727             :                 }
    1728             :                 SAL_WARN("starmath", "Not seen in the wild Equation Ruler Field");
    1729           0 :                 break;
    1730             :             case FONT:
    1731             :                 {
    1732           0 :                     MathTypeFont aFont;
    1733           0 :                     pS->ReadUChar( aFont.nTface );
    1734             :                     /*
    1735             :                     The typeface number is the negative (which makes it
    1736             :                     positive) of the typeface value (unbiased) that appears in
    1737             :                     CHAR records that might follow a given FONT record
    1738             :                     */
    1739           0 :                     aFont.nTface = 128-aFont.nTface;
    1740           0 :                     pS->ReadUChar( aFont.nStyle );
    1741           0 :                     aUserStyles.insert(aFont);
    1742           0 :                     std::vector<sal_Char> aSeq;
    1743             :                     while(true)
    1744             :                     {
    1745           0 :                         sal_Char nChar8(0);
    1746           0 :                         pS->ReadChar( nChar8 );
    1747           0 :                         if (nChar8 == 0)
    1748           0 :                             break;
    1749           0 :                         aSeq.push_back(nChar8);
    1750           0 :                     }
    1751             :                     // Do nothing to the font name now in aSeq!?
    1752             :                 }
    1753           0 :                 break;
    1754             :             case SIZE:
    1755           0 :                 HandleSetSize();
    1756           0 :                 break;
    1757             :             case 10:
    1758             :             case 11:
    1759             :             case 12:
    1760             :             case 13:
    1761             :             case 14:
    1762          40 :                 nLSize=nRecord-10;
    1763          40 :                 break;
    1764             :             case END:
    1765             :             default:
    1766          80 :                 break;
    1767             :         }
    1768             :     }
    1769         248 :     while (nRecord != END && !pS->IsEof());
    1770         160 :     while (nSetSize)
    1771             :     {
    1772           0 :         rRet += "}";
    1773           0 :         nSetSize--;
    1774             :     }
    1775         160 :     return nRet;
    1776             : }
    1777             : 
    1778             : /*Simply determine if we are at the end of a record or the end of a line,
    1779             :  *with fiddley logic to see if we are in a matrix or a pile or neither
    1780             : 
    1781             :  Note we cannot tell until after the event that this is the last entry
    1782             :  of a pile, so we must strip the last separator of a pile after this
    1783             :  is detected in the PILE handler
    1784             :  */
    1785          40 : void MathType::HandleMatrixSeparator(int nMatrixRows,int nMatrixCols,
    1786             :     int &rCurCol,int &rCurRow)
    1787             : {
    1788          40 :     if (nMatrixRows!=0)
    1789             :     {
    1790           0 :         if (rCurCol == nMatrixCols-1)
    1791             :         {
    1792           0 :             if (rCurRow != nMatrixRows-1)
    1793           0 :                 rRet += " {} ##\n";
    1794           0 :             if (nMatrixRows!=-1)
    1795             :             {
    1796           0 :                 rCurCol=0;
    1797           0 :                 rCurRow++;
    1798             :             }
    1799             :         }
    1800             :         else
    1801             :         {
    1802           0 :             rRet += " {} # ";
    1803           0 :             if (nMatrixRows!=-1)
    1804           0 :                 rCurCol++;
    1805             :             else
    1806           0 :                 rRet += "\n";
    1807             :         }
    1808             :     }
    1809          40 : }
    1810             : 
    1811             : /* set the alignment of the following term, but starmath currently
    1812             :  * cannot handle vertical alignment */
    1813           0 : void MathType::HandleAlign(sal_uInt8 nHorAlign, sal_uInt8 /*nVAlign*/, int &rSetAlign)
    1814             : {
    1815           0 :     switch(nHorAlign)
    1816             :     {
    1817             :     case 1:
    1818             :     default:
    1819           0 :         rRet += "alignl {";
    1820           0 :         break;
    1821             :     case 2:
    1822           0 :         rRet += "alignc {";
    1823           0 :         break;
    1824             :     case 3:
    1825           0 :         rRet += "alignr {";
    1826           0 :         break;
    1827             :     }
    1828           0 :     rSetAlign++;
    1829           0 : }
    1830             : 
    1831             : /* set size of text, complexity due to overuse of signedness as a flag
    1832             :  * indicator by mathtype file format*/
    1833          88 : bool MathType::HandleSize(sal_Int16 nLstSize,sal_Int16 nDefSize, int &rSetSize)
    1834             : {
    1835          88 :     bool bRet=false;
    1836          88 :     if (nLstSize < 0)
    1837             :     {
    1838           0 :         if ((-nLstSize/32 != nDefaultSize) && (-nLstSize/32 != nCurSize))
    1839             :         {
    1840           0 :             if (rSetSize)
    1841             :             {
    1842           0 :                 rSetSize--;
    1843           0 :                 rRet += "}";
    1844           0 :                 bRet=true;
    1845             :             }
    1846           0 :             if (-nLstSize/32 != nLastSize)
    1847             :             {
    1848           0 :                 nLastSize = nCurSize;
    1849           0 :                 rRet += " size ";
    1850           0 :                 rRet += OUString::number(-nLstSize/32);
    1851           0 :                 rRet += "{";
    1852           0 :                 bRet=true;
    1853           0 :                 rSetSize++;
    1854             :             }
    1855           0 :             nCurSize = -nLstSize/32;
    1856             :         }
    1857             :     }
    1858             :     else
    1859             :     {
    1860             :         /*sizetable should theoreticaly be filled with the default sizes
    1861             :          *of the various font groupings matching starmaths equivalents
    1862             :          in aTypeFaces, and a test would be done to see if the new font
    1863             :          size would be the same as what starmath would have chosen for
    1864             :          itself anyway in which case the size setting could be ignored*/
    1865          88 :         nLstSize = aSizeTable[nLstSize];
    1866          88 :         nLstSize = nLstSize + nDefSize;
    1867          88 :         if (nLstSize != nCurSize)
    1868             :         {
    1869          40 :             if (rSetSize)
    1870             :             {
    1871           0 :                 rSetSize--;
    1872           0 :                 rRet += "}";
    1873           0 :                 bRet=true;
    1874             :             }
    1875          40 :             if (nLstSize != nLastSize)
    1876             :             {
    1877          40 :                 nLastSize = nCurSize;
    1878          40 :                 rRet += " size ";
    1879          40 :                 rRet += OUString::number(nLstSize);
    1880          40 :                 rRet += "{";
    1881          40 :                 bRet=true;
    1882          40 :                 rSetSize++;
    1883             :             }
    1884          40 :             nCurSize = nLstSize;
    1885             :         }
    1886             :     }
    1887          88 :     return bRet;
    1888             : }
    1889             : 
    1890           0 : int MathType::ConvertFromStarMath( SfxMedium& rMedium )
    1891             : {
    1892           0 :     if (!pTree)
    1893           0 :         return 0;
    1894             : 
    1895           0 :     SvStream *pStream = rMedium.GetOutStream();
    1896           0 :     if ( pStream )
    1897             :     {
    1898           0 :         SvStorageRef pStor = new SotStorage( pStream, false );
    1899             : 
    1900             :         SvGlobalName aGName(0x0002ce02L, 0x0000, 0x0000,0xc0,0x00,
    1901           0 :             0x00,0x00,0x00,0x00,0x00,0x46 );
    1902           0 :         pStor->SetClass( aGName, 0, OUString("Microsoft Equation 3.0"));
    1903             : 
    1904             :         static sal_uInt8 const aCompObj[] = {
    1905             :             0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
    1906             :             0xFF, 0xFF, 0xFF, 0xFF, 0x02, 0xCE, 0x02, 0x00,
    1907             :             0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00,
    1908             :             0x00, 0x00, 0x00, 0x46, 0x17, 0x00, 0x00, 0x00,
    1909             :             0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
    1910             :             0x74, 0x20, 0x45, 0x71, 0x75, 0x61, 0x74, 0x69,
    1911             :             0x6F, 0x6E, 0x20, 0x33, 0x2E, 0x30, 0x00, 0x0C,
    1912             :             0x00, 0x00, 0x00, 0x44, 0x53, 0x20, 0x45, 0x71,
    1913             :             0x75, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x00, 0x0B,
    1914             :             0x00, 0x00, 0x00, 0x45, 0x71, 0x75, 0x61, 0x74,
    1915             :             0x69, 0x6F, 0x6E, 0x2E, 0x33, 0x00, 0xF4, 0x39,
    1916             :             0xB2, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    1917             :             0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    1918             :         };
    1919           0 :         SvStorageStreamRef xStor( pStor->OpenSotStream(OUString("\1CompObj")));
    1920           0 :         xStor->Write(aCompObj,sizeof(aCompObj));
    1921             : 
    1922             :         static sal_uInt8 const aOle[] = {
    1923             :             0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
    1924             :             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    1925             :             0x00, 0x00, 0x00, 0x00
    1926             :             };
    1927           0 :         SvStorageStreamRef xStor2( pStor->OpenSotStream(OUString("\1Ole")));
    1928           0 :         xStor2->Write(aOle,sizeof(aOle));
    1929           0 :         xStor.Clear();
    1930           0 :         xStor2.Clear();
    1931             : 
    1932           0 :         SvStorageStreamRef xSrc = pStor->OpenSotStream(OUString("Equation Native"));
    1933           0 :         if ( (!xSrc.Is()) || (SVSTREAM_OK != xSrc->GetError()))
    1934           0 :             return 0;
    1935             : 
    1936           0 :         pS = &xSrc;
    1937           0 :         pS->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
    1938             : 
    1939           0 :         pS->SeekRel(EQNOLEFILEHDR_SIZE); //Skip 28byte Header and fill it in later
    1940           0 :         pS->WriteUChar( sal_uInt8(0x03) );
    1941           0 :         pS->WriteUChar( sal_uInt8(0x01) );
    1942           0 :         pS->WriteUChar( sal_uInt8(0x01) );
    1943           0 :         pS->WriteUChar( sal_uInt8(0x03) );
    1944           0 :         pS->WriteUChar( sal_uInt8(0x00) );
    1945           0 :         sal_uInt32 nSize = pS->Tell();
    1946           0 :         nPendingAttributes=0;
    1947             : 
    1948           0 :         HandleNodes(pTree);
    1949           0 :         pS->WriteUChar( sal_uInt8(END) );
    1950             : 
    1951           0 :         nSize = pS->Tell()-nSize;
    1952           0 :         pS->Seek(0);
    1953           0 :         EQNOLEFILEHDR aHdr(nSize+4+1);
    1954           0 :         aHdr.Write(pS);
    1955             : 
    1956           0 :         pStor->Commit();
    1957             :     }
    1958             : 
    1959           0 :     return 1;
    1960             : }
    1961             : 
    1962             : 
    1963           0 : sal_uInt8 MathType::HandleNodes(SmNode *pNode,int nLevel)
    1964             : {
    1965           0 :     bool bRet=false;
    1966           0 :     switch(pNode->GetType())
    1967             :     {
    1968             :         case NATTRIBUT:
    1969           0 :             HandleAttributes(pNode,nLevel);
    1970           0 :             break;
    1971             :         case NTEXT:
    1972           0 :             HandleText(pNode,nLevel);
    1973           0 :             break;
    1974             :         case NVERTICAL_BRACE:
    1975           0 :             HandleVerticalBrace(pNode,nLevel);
    1976           0 :             break;
    1977             :         case NBRACE:
    1978           0 :             HandleBrace(pNode,nLevel);
    1979           0 :             break;
    1980             :         case NOPER:
    1981           0 :             HandleOperator(pNode,nLevel);
    1982           0 :             break;
    1983             :         case NBINVER:
    1984           0 :             HandleFractions(pNode,nLevel);
    1985           0 :             break;
    1986             :         case NROOT:
    1987           0 :             HandleRoot(pNode,nLevel);
    1988           0 :             break;
    1989             :         case NSPECIAL:
    1990             :             {
    1991           0 :             SmTextNode *pText=(SmTextNode *)pNode;
    1992             :             //if the token str and the result text are the same then this
    1993             :             //is to be seen as text, else assume it's a mathchar
    1994           0 :             if (pText->GetText() == pText->GetToken().aText)
    1995           0 :                 HandleText(pText,nLevel);
    1996             :             else
    1997           0 :                 HandleMath(pText,nLevel);
    1998             :             }
    1999           0 :             break;
    2000             :         case NMATH:
    2001             :         case NMATHIDENT:
    2002           0 :             HandleMath(pNode,nLevel);
    2003           0 :             break;
    2004             :         case NSUBSUP:
    2005           0 :             HandleSubSupScript(pNode,nLevel);
    2006           0 :             break;
    2007             :         case NEXPRESSION:
    2008             :             {
    2009           0 :             sal_uInt16  nSize = pNode->GetNumSubNodes();
    2010           0 :             for (sal_uInt16 i = 0; i < nSize; i++)
    2011           0 :                 if (SmNode *pTemp = pNode->GetSubNode(i))
    2012           0 :                     HandleNodes(pTemp,nLevel+1);
    2013             :             }
    2014           0 :             break;
    2015             :         case NTABLE:
    2016             :             //Root Node, PILE equivalent, i.e. vertical stack
    2017           0 :             HandleTable(pNode,nLevel);
    2018           0 :             break;
    2019             :         case NMATRIX:
    2020           0 :             HandleSmMatrix((SmMatrixNode *)pNode,nLevel);
    2021           0 :             break;
    2022             :         case NLINE:
    2023             :             {
    2024           0 :             pS->WriteUChar( sal_uInt8(0x0a) );
    2025           0 :             pS->WriteUChar( sal_uInt8(LINE) );
    2026           0 :             sal_uInt16  nSize = pNode->GetNumSubNodes();
    2027           0 :             for (sal_uInt16 i = 0; i < nSize; i++)
    2028           0 :                 if (SmNode *pTemp = pNode->GetSubNode(i))
    2029           0 :                     HandleNodes(pTemp,nLevel+1);
    2030           0 :             pS->WriteUChar( sal_uInt8(END) );
    2031             :             }
    2032           0 :             break;
    2033             :         case NALIGN:
    2034           0 :             HandleMAlign(pNode,nLevel);
    2035           0 :             break;
    2036             :         case NBLANK:
    2037           0 :             pS->WriteUChar( sal_uInt8(CHAR) );
    2038           0 :             pS->WriteUChar( sal_uInt8(0x98) );
    2039           0 :             if (pNode->GetToken().eType == TSBLANK)
    2040           0 :                 pS->WriteUInt16( sal_uInt16(0xEB04) );
    2041             :             else
    2042           0 :                 pS->WriteUInt16( sal_uInt16(0xEB05) );
    2043           0 :             break;
    2044             :         default:
    2045             :             {
    2046           0 :             sal_uInt16  nSize = pNode->GetNumSubNodes();
    2047           0 :             for (sal_uInt16 i = 0; i < nSize; i++)
    2048           0 :                 if (SmNode *pTemp = pNode->GetSubNode(i))
    2049           0 :                     HandleNodes(pTemp,nLevel+1);
    2050             :             }
    2051           0 :             break;
    2052             :     }
    2053           0 :     return bRet;
    2054             : }
    2055             : 
    2056             : 
    2057           0 : int MathType::StartTemplate(sal_uInt16 nSelector,sal_uInt16 nVariation)
    2058             : {
    2059           0 :     int nOldPending=nPendingAttributes;
    2060           0 :     pS->WriteUChar( sal_uInt8(TMPL) ); //Template
    2061           0 :     pS->WriteUChar( sal_uInt8(nSelector) ); //selector
    2062           0 :     pS->WriteUChar( sal_uInt8(nVariation) ); //variation
    2063           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //options
    2064           0 :     pS->WriteUChar( sal_uInt8(LINE) );
    2065             :     //theres just no way we can now handle any character
    2066             :     //attributes (from mathtypes perspective) centered
    2067             :     //over an expression but above template attribute
    2068             :     //such as widevec and similar constructs
    2069             :     //we have to drop them
    2070           0 :     nPendingAttributes=0;
    2071           0 :     return nOldPending;
    2072             : }
    2073             : 
    2074           0 : void MathType::EndTemplate(int nOldPendingAttributes)
    2075             : {
    2076           0 :     pS->WriteUChar( sal_uInt8(END) ); //end line
    2077           0 :     pS->WriteUChar( sal_uInt8(END) ); //end template
    2078           0 :     nPendingAttributes=nOldPendingAttributes;
    2079           0 : }
    2080             : 
    2081             : 
    2082           0 : void MathType::HandleSmMatrix(SmMatrixNode *pMatrix,int nLevel)
    2083             : {
    2084           0 :     pS->WriteUChar( sal_uInt8(MATRIX) );
    2085           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //vAlign ?
    2086           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //h_just
    2087           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //v_just
    2088           0 :     pS->WriteUChar( sal_uInt8(pMatrix->GetNumRows()) ); //v_just
    2089           0 :     pS->WriteUChar( sal_uInt8(pMatrix->GetNumCols()) ); //v_just
    2090           0 :     int nBytes=(pMatrix->GetNumRows()+1)*2/8;
    2091           0 :     if (((pMatrix->GetNumRows()+1)*2)%8)
    2092           0 :         nBytes++;
    2093           0 :     for (sal_uInt16 j = 0; j < nBytes; j++)
    2094           0 :         pS->WriteUChar( sal_uInt8(0x00) ); //row_parts
    2095           0 :     nBytes=(pMatrix->GetNumCols()+1)*2/8;
    2096           0 :     if (((pMatrix->GetNumCols()+1)*2)%8)
    2097           0 :         nBytes++;
    2098           0 :     for (sal_uInt16 k = 0; k < nBytes; k++)
    2099           0 :         pS->WriteUChar( sal_uInt8(0x00) ); //col_parts
    2100           0 :     sal_uInt16  nSize = pMatrix->GetNumSubNodes();
    2101           0 :     for (sal_uInt16 i = 0; i < nSize; i++)
    2102           0 :         if (SmNode *pTemp = pMatrix->GetSubNode(i))
    2103             :         {
    2104           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2105           0 :             HandleNodes(pTemp,nLevel+1);
    2106           0 :             pS->WriteUChar( sal_uInt8(END) ); //end line
    2107             :         }
    2108           0 :     pS->WriteUChar( sal_uInt8(END) );
    2109           0 : }
    2110             : 
    2111             : 
    2112             : //Root Node, PILE equivalent, i.e. vertical stack
    2113           0 : void MathType::HandleTable(SmNode *pNode,int nLevel)
    2114             : {
    2115           0 :     sal_uInt16  nSize = pNode->GetNumSubNodes();
    2116             :     //The root of the starmath is a table, if
    2117             :     //we convert this them each iteration of
    2118             :     //conversion from starmath to mathtype will
    2119             :     //add an extra unnecessary level to the
    2120             :     //mathtype output stack which would grow
    2121             :     //without bound in a multi step conversion
    2122             : 
    2123           0 :     if (nLevel == 0)
    2124           0 :         pS->WriteUChar( sal_uInt8(0x0A) ); //initial size
    2125             : 
    2126           0 :     if ( nLevel || (nSize >1))
    2127             :     {
    2128           0 :         pS->WriteUChar( sal_uInt8(PILE) );
    2129           0 :         pS->WriteUChar( sal_uInt8(nHAlign) ); //vAlign ?
    2130           0 :         pS->WriteUChar( sal_uInt8(0x01) ); //hAlign
    2131             :     }
    2132             : 
    2133           0 :     for (sal_uInt16 i = 0; i < nSize; i++)
    2134           0 :         if (SmNode *pTemp = pNode->GetSubNode(i))
    2135             :         {
    2136           0 :             pS->WriteUChar( sal_uInt8(LINE) );
    2137           0 :             HandleNodes(pTemp,nLevel+1);
    2138           0 :             pS->WriteUChar( sal_uInt8(END) );
    2139             :         }
    2140           0 :     if (nLevel || (nSize>1))
    2141           0 :         pS->WriteUChar( sal_uInt8(END) );
    2142           0 : }
    2143             : 
    2144             : 
    2145           0 : void MathType::HandleRoot(SmNode *pNode,int nLevel)
    2146             : {
    2147             :     SmNode *pTemp;
    2148           0 :     pS->WriteUChar( sal_uInt8(TMPL) ); //Template
    2149           0 :     pS->WriteUChar( sal_uInt8(0x0D) ); //selector
    2150           0 :     if (pNode->GetSubNode(0))
    2151           0 :         pS->WriteUChar( sal_uInt8(0x01) ); //variation
    2152             :     else
    2153           0 :         pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2154           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //options
    2155             : 
    2156           0 :     if (NULL != (pTemp = pNode->GetSubNode(2)))
    2157             :     {
    2158           0 :         pS->WriteUChar( sal_uInt8(LINE) ); //line
    2159           0 :         HandleNodes(pTemp,nLevel+1);
    2160           0 :         pS->WriteUChar( sal_uInt8(END) );
    2161             :     }
    2162             : 
    2163           0 :     if (NULL != (pTemp = pNode->GetSubNode(0)))
    2164             :     {
    2165           0 :         pS->WriteUChar( sal_uInt8(LINE) ); //line
    2166           0 :         HandleNodes(pTemp,nLevel+1);
    2167           0 :         pS->WriteUChar( sal_uInt8(END) );
    2168             :     }
    2169             :     else
    2170           0 :         pS->WriteUChar( sal_uInt8(LINE|0x10) ); //dummy line
    2171             : 
    2172             : 
    2173             : 
    2174           0 :     pS->WriteUChar( sal_uInt8(END) );
    2175           0 : }
    2176             : 
    2177           0 : sal_uInt8 MathType::HandleCScript(SmNode *pNode,SmNode *pContent,int nLevel,
    2178             :     sal_uLong *pPos,bool bTest)
    2179             : {
    2180           0 :     sal_uInt8 nVariation2=0xff;
    2181             : 
    2182           0 :     if (bTest && pNode->GetSubNode(CSUP+1))
    2183             :     {
    2184           0 :         nVariation2=0;
    2185           0 :         if (pNode->GetSubNode(CSUB+1))
    2186           0 :             nVariation2=2;
    2187             :     }
    2188           0 :     else if (pNode->GetSubNode(CSUB+1))
    2189           0 :         nVariation2=1;
    2190             : 
    2191           0 :     if (nVariation2!=0xff)
    2192             :     {
    2193           0 :         if (pPos)
    2194           0 :             *pPos = pS->Tell();
    2195           0 :         pS->WriteUChar( sal_uInt8(TMPL) ); //Template
    2196           0 :         pS->WriteUChar( sal_uInt8(0x2B) ); //selector
    2197           0 :         pS->WriteUChar( nVariation2 );
    2198           0 :         pS->WriteUChar( sal_uInt8(0x00) ); //options
    2199             : 
    2200           0 :         if (pContent)
    2201             :         {
    2202           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2203           0 :             HandleNodes(pContent,nLevel+1);
    2204           0 :             pS->WriteUChar( sal_uInt8(END) ); //line
    2205             :         }
    2206             :         else
    2207           0 :             pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2208             : 
    2209           0 :         pS->WriteUChar( sal_uInt8(0x0B) );
    2210             : 
    2211             :         SmNode *pTemp;
    2212           0 :         if (NULL != (pTemp = pNode->GetSubNode(CSUB+1)))
    2213             :         {
    2214           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2215           0 :             HandleNodes(pTemp,nLevel+1);
    2216           0 :             pS->WriteUChar( sal_uInt8(END) ); //line
    2217             :         }
    2218             :         else
    2219           0 :             pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2220           0 :         if (bTest && NULL != (pTemp = pNode->GetSubNode(CSUP+1)))
    2221             :         {
    2222           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2223           0 :             HandleNodes(pTemp,nLevel+1);
    2224           0 :             pS->WriteUChar( sal_uInt8(END) ); //line
    2225             :         }
    2226             :         else
    2227           0 :             pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2228             :     }
    2229           0 :     return nVariation2;
    2230             : }
    2231             : 
    2232             : 
    2233             : 
    2234             : /*
    2235             :  Sub and Sup scripts and another problem area, StarMath
    2236             :  can have all possible options used at the same time, whereas
    2237             :  Mathtype cannot. The ordering of the nodes for each system
    2238             :  is quite different as well leading to some complexity
    2239             :  */
    2240           0 : void MathType::HandleSubSupScript(SmNode *pNode,int nLevel)
    2241             : {
    2242           0 :     sal_uInt8 nVariation=0xff;
    2243           0 :     if (pNode->GetSubNode(LSUP+1))
    2244             :     {
    2245           0 :         nVariation=0;
    2246           0 :         if (pNode->GetSubNode(LSUB+1))
    2247           0 :             nVariation=2;
    2248             :     }
    2249           0 :     else if ( NULL != pNode->GetSubNode(LSUB+1) )
    2250           0 :         nVariation=1;
    2251             : 
    2252             :     SmNode *pTemp;
    2253           0 :     if (nVariation!=0xff)
    2254             :     {
    2255           0 :         pS->WriteUChar( sal_uInt8(TMPL) ); //Template
    2256           0 :         pS->WriteUChar( sal_uInt8(0x2c) ); //selector
    2257           0 :         pS->WriteUChar( nVariation );
    2258           0 :         pS->WriteUChar( sal_uInt8(0x00) ); //options
    2259           0 :         pS->WriteUChar( sal_uInt8(0x0B) );
    2260             : 
    2261           0 :         if (NULL != (pTemp = pNode->GetSubNode(LSUB+1)))
    2262             :         {
    2263           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2264           0 :             HandleNodes(pTemp,nLevel+1);
    2265           0 :             pS->WriteUChar( sal_uInt8(END) ); //line
    2266             :         }
    2267             :         else
    2268           0 :             pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2269           0 :         if (NULL != (pTemp = pNode->GetSubNode(LSUP+1)))
    2270             :         {
    2271           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2272           0 :             HandleNodes(pTemp,nLevel+1);
    2273           0 :             pS->WriteUChar( sal_uInt8(END) ); //line
    2274             :         }
    2275             :         else
    2276           0 :             pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2277           0 :         pS->WriteUChar( sal_uInt8(END) );
    2278           0 :         nVariation=0xff;
    2279             :     }
    2280             : 
    2281             : 
    2282           0 :     sal_uInt8 nVariation2=HandleCScript(pNode,NULL,nLevel);
    2283             : 
    2284           0 :     if (NULL != (pTemp = pNode->GetSubNode(0)))
    2285             :     {
    2286           0 :         HandleNodes(pTemp,nLevel+1);
    2287             :     }
    2288             : 
    2289           0 :     if (nVariation2 != 0xff)
    2290           0 :         pS->WriteUChar( sal_uInt8(END) );
    2291             : 
    2292           0 :     if (NULL != (pNode->GetSubNode(RSUP+1)))
    2293             :     {
    2294           0 :         nVariation=0;
    2295           0 :         if (pNode->GetSubNode(RSUB+1))
    2296           0 :             nVariation=2;
    2297             :     }
    2298           0 :     else if (NULL != pNode->GetSubNode(RSUB+1))
    2299           0 :         nVariation=1;
    2300             : 
    2301           0 :     if (nVariation!=0xff)
    2302             :     {
    2303           0 :         pS->WriteUChar( sal_uInt8(TMPL) ); //Template
    2304           0 :         pS->WriteUChar( sal_uInt8(0x0F) ); //selector
    2305           0 :         pS->WriteUChar( nVariation );
    2306           0 :         pS->WriteUChar( sal_uInt8(0x00) ); //options
    2307           0 :         pS->WriteUChar( sal_uInt8(0x0B) );
    2308             : 
    2309           0 :         if (NULL != (pTemp = pNode->GetSubNode(RSUB+1)))
    2310             :         {
    2311           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2312           0 :             HandleNodes(pTemp,nLevel+1);
    2313           0 :             pS->WriteUChar( sal_uInt8(END) ); //line
    2314             :         }
    2315             :         else
    2316           0 :             pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2317           0 :         if (NULL != (pTemp = pNode->GetSubNode(RSUP+1)))
    2318             :         {
    2319           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2320           0 :             HandleNodes(pTemp,nLevel+1);
    2321           0 :             pS->WriteUChar( sal_uInt8(END) ); //line
    2322             :         }
    2323             :         else
    2324           0 :             pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2325           0 :     pS->WriteUChar( sal_uInt8(END) ); //line
    2326             :     }
    2327             : 
    2328             :     //After subscript mathtype will keep the size of
    2329             :     //normal text at the subscript size, sigh.
    2330           0 :     pS->WriteUChar( sal_uInt8(0x0A) );
    2331           0 : }
    2332             : 
    2333             : 
    2334           0 : void MathType::HandleFractions(SmNode *pNode,int nLevel)
    2335             : {
    2336             :     SmNode *pTemp;
    2337           0 :     pS->WriteUChar( sal_uInt8(TMPL) ); //Template
    2338           0 :     pS->WriteUChar( sal_uInt8(0x0E) ); //selector
    2339           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2340           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //options
    2341             : 
    2342           0 :     pS->WriteUChar( sal_uInt8(0x0A) );
    2343           0 :     pS->WriteUChar( sal_uInt8(LINE) ); //line
    2344           0 :     if (NULL != (pTemp = pNode->GetSubNode(0)))
    2345           0 :         HandleNodes(pTemp,nLevel+1);
    2346           0 :     pS->WriteUChar( sal_uInt8(END) );
    2347             : 
    2348           0 :     pS->WriteUChar( sal_uInt8(0x0A) );
    2349           0 :     pS->WriteUChar( sal_uInt8(LINE) ); //line
    2350           0 :     if (NULL != (pTemp = pNode->GetSubNode(2)))
    2351           0 :         HandleNodes(pTemp,nLevel+1);
    2352           0 :     pS->WriteUChar( sal_uInt8(END) );
    2353             : 
    2354           0 :     pS->WriteUChar( sal_uInt8(END) );
    2355           0 : }
    2356             : 
    2357             : 
    2358           0 : void MathType::HandleBrace(SmNode *pNode,int nLevel)
    2359             : {
    2360             :     SmNode *pTemp;
    2361           0 :     SmNode *pLeft=pNode->GetSubNode(0);
    2362           0 :     SmNode *pRight=pNode->GetSubNode(2);
    2363             : 
    2364           0 :     pS->WriteUChar( sal_uInt8(TMPL) ); //Template
    2365           0 :     bIsReInterpBrace=false;
    2366           0 :     sal_uInt8 nBSpec=0x10;
    2367           0 :     sal_uLong nLoc = pS->Tell();
    2368           0 :     if (pLeft)
    2369             :     {
    2370           0 :         switch (pLeft->GetToken().eType)
    2371             :         {
    2372             :             case TLANGLE:
    2373           0 :                 pS->WriteUChar( sal_uInt8(tmANGLE) ); //selector
    2374           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2375           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //options
    2376           0 :                 break;
    2377             :             case TLBRACE:
    2378           0 :                 pS->WriteUChar( sal_uInt8(tmBRACE) ); //selector
    2379           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2380           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //options
    2381           0 :                 nBSpec+=3;
    2382           0 :                 break;
    2383             :             case TLBRACKET:
    2384           0 :                 pS->WriteUChar( sal_uInt8(tmBRACK) ); //selector
    2385           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2386           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //options
    2387           0 :                 nBSpec+=3;
    2388           0 :                 break;
    2389             :             case TLFLOOR:
    2390           0 :                 pS->WriteUChar( sal_uInt8(tmFLOOR) ); //selector
    2391           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2392           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //options
    2393           0 :                 break;
    2394             :             case TLLINE:
    2395           0 :                 pS->WriteUChar( sal_uInt8(tmBAR) ); //selector
    2396           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2397           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //options
    2398           0 :                 nBSpec+=3;
    2399           0 :                 break;
    2400             :             case TLDLINE:
    2401           0 :                 pS->WriteUChar( sal_uInt8(tmDBAR) ); //selector
    2402           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2403           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //options
    2404           0 :                 break;
    2405             :             default:
    2406           0 :                 pS->WriteUChar( sal_uInt8(tmPAREN) ); //selector
    2407           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //variation
    2408           0 :                 pS->WriteUChar( sal_uInt8(0x00) ); //options
    2409           0 :                 nBSpec+=3;
    2410           0 :                 break;
    2411             :         }
    2412             :     }
    2413             : 
    2414           0 :     if (NULL != (pTemp = pNode->GetSubNode(1)))
    2415             :     {
    2416           0 :         pS->WriteUChar( sal_uInt8(LINE) ); //line
    2417           0 :         HandleNodes(pTemp,nLevel+1);
    2418           0 :         pS->WriteUChar( sal_uInt8(END) ); //options
    2419             :     }
    2420           0 :     nSpec=nBSpec;
    2421           0 :     if (pLeft)
    2422           0 :         HandleNodes(pLeft,nLevel+1);
    2423           0 :     if (bIsReInterpBrace)
    2424             :     {
    2425           0 :         sal_uLong nLoc2 = pS->Tell();
    2426           0 :         pS->Seek(nLoc);
    2427           0 :         pS->WriteUChar( sal_uInt8(0x2D) );
    2428           0 :         pS->Seek(nLoc2);
    2429           0 :         pS->WriteUChar( sal_uInt8(CHAR) );
    2430           0 :         pS->WriteUChar( sal_uInt8(0x96) );
    2431           0 :         pS->WriteUInt16( sal_uInt16(0xEC07) );
    2432           0 :         bIsReInterpBrace=false;
    2433             :     }
    2434           0 :     if (pRight)
    2435           0 :         HandleNodes(pRight,nLevel+1);
    2436           0 :     nSpec=0x0;
    2437           0 :     pS->WriteUChar( sal_uInt8(END) );
    2438           0 : }
    2439             : 
    2440             : 
    2441           0 : void MathType::HandleVerticalBrace(SmNode *pNode,int nLevel)
    2442             : {
    2443             :     SmNode *pTemp;
    2444           0 :     pS->WriteUChar( sal_uInt8(TMPL) ); //Template
    2445           0 :     if (pNode->GetToken().eType == TUNDERBRACE)
    2446           0 :         pS->WriteUChar( sal_uInt8(tmLHBRACE) ); //selector
    2447             :     else
    2448           0 :         pS->WriteUChar( sal_uInt8(tmUHBRACE) ); //selector
    2449           0 :     pS->WriteUChar( sal_uInt8(0x01) ); //variation
    2450           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //options
    2451             : 
    2452           0 :     if (NULL != (pTemp = pNode->GetSubNode(0)))
    2453             :     {
    2454           0 :         pS->WriteUChar( sal_uInt8(LINE) ); //line
    2455           0 :         HandleNodes(pTemp,nLevel+1);
    2456           0 :         pS->WriteUChar( sal_uInt8(END) ); //options
    2457             :     }
    2458             : 
    2459           0 :     if (NULL != (pTemp = pNode->GetSubNode(2)))
    2460             :     {
    2461           0 :         pS->WriteUChar( sal_uInt8(LINE) ); //line
    2462           0 :         HandleNodes(pTemp,nLevel+1);
    2463           0 :         pS->WriteUChar( sal_uInt8(END) ); //options
    2464             :     }
    2465           0 :     pS->WriteUChar( sal_uInt8(END) );
    2466           0 : }
    2467             : 
    2468           0 : void MathType::HandleOperator(SmNode *pNode,int nLevel)
    2469             : {
    2470           0 :     if (HandleLim(pNode,nLevel))
    2471           0 :         return;
    2472             : 
    2473             :     sal_uLong nPos;
    2474             :     sal_uInt8 nVariation;
    2475             : 
    2476           0 :     switch (pNode->GetToken().eType)
    2477             :     {
    2478             :         case TIINT:
    2479             :         case TIIINT:
    2480             :         case TLINT:
    2481             :         case TLLINT:
    2482             :         case TLLLINT:
    2483           0 :             nVariation=HandleCScript(pNode->GetSubNode(0),
    2484           0 :                 pNode->GetSubNode(1),nLevel,&nPos,false);
    2485           0 :             break;
    2486             :         default:
    2487           0 :             nVariation=HandleCScript(pNode->GetSubNode(0),
    2488           0 :                 pNode->GetSubNode(1),nLevel,&nPos);
    2489           0 :             break;
    2490             :     }
    2491             : 
    2492           0 :     sal_uInt8 nOldVariation=nVariation;
    2493           0 :     sal_uInt8 nIntVariation=nVariation;
    2494             : 
    2495           0 :     sal_uLong nPos2=0;
    2496           0 :     if (nVariation != 0xff)
    2497             :     {
    2498           0 :         nPos2 = pS->Tell();
    2499           0 :         pS->Seek(nPos);
    2500           0 :         if (nVariation == 2)
    2501             :         {
    2502           0 :             nIntVariation=0;
    2503           0 :             nVariation = 1;
    2504             :         }
    2505           0 :         else if (nVariation == 0)
    2506           0 :             nVariation = 1;
    2507           0 :         else if (nVariation == 1)
    2508           0 :             nVariation = 0;
    2509             :     }
    2510             :     else
    2511             :     {
    2512           0 :         nVariation = 2;
    2513           0 :         nIntVariation=0;
    2514             :     }
    2515           0 :     pS->WriteUChar( sal_uInt8(TMPL) );
    2516           0 :     switch(pNode->GetToken().eType)
    2517             :     {
    2518             :     case TINT:
    2519             :     case TINTD:
    2520           0 :         if (nOldVariation != 0xff)
    2521           0 :             pS->WriteUChar( sal_uInt8(0x18) ); //selector
    2522             :         else
    2523           0 :             pS->WriteUChar( sal_uInt8(0x15) ); //selector
    2524           0 :         pS->WriteUChar( nIntVariation ); //variation
    2525           0 :         break;
    2526             :     case TIINT:
    2527           0 :         if (nOldVariation != 0xff)
    2528             :         {
    2529           0 :             pS->WriteUChar( sal_uInt8(0x19) );
    2530           0 :             pS->WriteUChar( sal_uInt8(0x01) );
    2531             :         }
    2532             :         else
    2533             :         {
    2534           0 :             pS->WriteUChar( sal_uInt8(0x16) );
    2535           0 :             pS->WriteUChar( sal_uInt8(0x00) );
    2536             :         }
    2537           0 :         break;
    2538             :     case TIIINT:
    2539           0 :         if (nOldVariation != 0xff)
    2540             :         {
    2541           0 :             pS->WriteUChar( sal_uInt8(0x1a) );
    2542           0 :             pS->WriteUChar( sal_uInt8(0x01) );
    2543             :         }
    2544             :         else
    2545             :         {
    2546           0 :             pS->WriteUChar( sal_uInt8(0x17) );
    2547           0 :             pS->WriteUChar( sal_uInt8(0x00) );
    2548             :         }
    2549           0 :         break;
    2550             :     case TLINT:
    2551           0 :         if (nOldVariation != 0xff)
    2552             :         {
    2553           0 :             pS->WriteUChar( sal_uInt8(0x18) );
    2554           0 :             pS->WriteUChar( sal_uInt8(0x02) );
    2555             :         }
    2556             :         else
    2557             :         {
    2558           0 :             pS->WriteUChar( sal_uInt8(0x15) );
    2559           0 :             pS->WriteUChar( sal_uInt8(0x03) );
    2560             :         }
    2561           0 :         break;
    2562             :     case TLLINT:
    2563           0 :         if (nOldVariation != 0xff)
    2564             :         {
    2565           0 :             pS->WriteUChar( sal_uInt8(0x19) );
    2566           0 :             pS->WriteUChar( sal_uInt8(0x00) );
    2567             :         }
    2568             :         else
    2569             :         {
    2570           0 :             pS->WriteUChar( sal_uInt8(0x16) );
    2571           0 :             pS->WriteUChar( sal_uInt8(0x02) );
    2572             :         }
    2573           0 :         break;
    2574             :     case TLLLINT:
    2575           0 :         if (nOldVariation != 0xff)
    2576             :         {
    2577           0 :             pS->WriteUChar( sal_uInt8(0x1a) );
    2578           0 :             pS->WriteUChar( sal_uInt8(0x00) );
    2579             :         }
    2580             :         else
    2581             :         {
    2582           0 :             pS->WriteUChar( sal_uInt8(0x17) );
    2583           0 :             pS->WriteUChar( sal_uInt8(0x02) );
    2584             :         }
    2585           0 :         break;
    2586             :     case TSUM:
    2587             :     default:
    2588           0 :         pS->WriteUChar( sal_uInt8(0x1d) );
    2589           0 :         pS->WriteUChar( nVariation );
    2590           0 :         break;
    2591             :     case TPROD:
    2592           0 :         pS->WriteUChar( sal_uInt8(0x1f) );
    2593           0 :         pS->WriteUChar( nVariation );
    2594           0 :         break;
    2595             :     case TCOPROD:
    2596           0 :         pS->WriteUChar( sal_uInt8(0x21) );
    2597           0 :         pS->WriteUChar( nVariation );
    2598           0 :         break;
    2599             :     }
    2600           0 :     pS->WriteUChar( sal_uInt8(0x00) ); //options
    2601             : 
    2602           0 :     if (nPos2)
    2603           0 :         pS->Seek(nPos2);
    2604             :     else
    2605             :     {
    2606           0 :         pS->WriteUChar( sal_uInt8(LINE) ); //line
    2607           0 :         HandleNodes(pNode->GetSubNode(1),nLevel+1);
    2608           0 :         pS->WriteUChar( sal_uInt8(END) ); //line
    2609           0 :         pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2610           0 :         pS->WriteUChar( sal_uInt8(LINE|0x10) );
    2611             :     }
    2612             : 
    2613             : 
    2614           0 :     pS->WriteUChar( sal_uInt8(0x0D) );
    2615           0 :     switch(pNode->GetToken().eType)
    2616             :     {
    2617             :     case TSUM:
    2618             :     default:
    2619           0 :         pS->WriteUChar( sal_uInt8(CHAR) );
    2620           0 :         pS->WriteUChar( sal_uInt8(0x86) );
    2621           0 :         pS->WriteUInt16( sal_uInt16(0x2211) );
    2622           0 :         break;
    2623             :     case TPROD:
    2624           0 :         pS->WriteUChar( sal_uInt8(CHAR) );
    2625           0 :         pS->WriteUChar( sal_uInt8(0x86) );
    2626           0 :         pS->WriteUInt16( sal_uInt16(0x220F) );
    2627           0 :         break;
    2628             :     case TCOPROD:
    2629           0 :         pS->WriteUChar( sal_uInt8(CHAR) );
    2630           0 :         pS->WriteUChar( sal_uInt8(0x8B) );
    2631           0 :         pS->WriteUInt16( sal_uInt16(0x2210) );
    2632           0 :         break;
    2633             :     case TIIINT:
    2634             :     case TLLLINT:
    2635           0 :         pS->WriteUChar( sal_uInt8(CHAR) );
    2636           0 :         pS->WriteUChar( sal_uInt8(0x86) );
    2637           0 :         pS->WriteUInt16( sal_uInt16(0x222B) );
    2638             :         ///fall-through
    2639             :     case TIINT:
    2640             :     case TLLINT:
    2641           0 :         pS->WriteUChar( sal_uInt8(CHAR) );
    2642           0 :         pS->WriteUChar( sal_uInt8(0x86) );
    2643           0 :         pS->WriteUInt16( sal_uInt16(0x222B) );
    2644             :         ///fall-through
    2645             :     case TINT:
    2646             :     case TINTD:
    2647             :     case TLINT:
    2648           0 :         pS->WriteUChar( sal_uInt8(CHAR) );
    2649           0 :         pS->WriteUChar( sal_uInt8(0x86) );
    2650           0 :         pS->WriteUInt16( sal_uInt16(0x222B) );
    2651           0 :         break;
    2652             :     }
    2653           0 :     pS->WriteUChar( sal_uInt8(END) );
    2654           0 :     pS->WriteUChar( sal_uInt8(0x0A) );
    2655             : }
    2656             : 
    2657             : 
    2658           0 : int MathType::HandlePile(int &rSetAlign,int nLevel,sal_uInt8 nSelector,
    2659             :     sal_uInt8 nVariation)
    2660             : {
    2661           0 :     pS->ReadUChar( nHAlign );
    2662           0 :     pS->ReadUChar( nVAlign );
    2663             : 
    2664           0 :     HandleAlign(nHAlign,nVAlign,rSetAlign);
    2665             : 
    2666           0 :     rRet += " stack {\n";
    2667           0 :     int nRet = HandleRecords(nLevel+1,nSelector,nVariation,-1,-1);
    2668           0 :     rRet = rRet.replaceAt(rRet.getLength()-3,2,"");
    2669           0 :     rRet += "} ";
    2670             : 
    2671           0 :     while (rSetAlign)
    2672             :     {
    2673           0 :         rRet += "} ";
    2674           0 :         rSetAlign--;
    2675             :     }
    2676           0 :     return nRet;
    2677             : }
    2678             : 
    2679           0 : int MathType::HandleMatrix(int nLevel,sal_uInt8 nSelector,
    2680             :     sal_uInt8 nVariation)
    2681             : {
    2682             :     sal_uInt8 nH_just,nV_just,nRows,nCols;
    2683           0 :     pS->ReadUChar( nVAlign );
    2684           0 :     pS->ReadUChar( nH_just );
    2685           0 :     pS->ReadUChar( nV_just );
    2686           0 :     pS->ReadUChar( nRows );
    2687           0 :     pS->ReadUChar( nCols );
    2688           0 :     int nBytes = ((nRows+1)*2)/8;
    2689           0 :     if (((nRows+1)*2)%8)
    2690           0 :         nBytes++;
    2691           0 :     pS->SeekRel(nBytes);
    2692           0 :     nBytes = ((nCols+1)*2)/8;
    2693           0 :     if (((nCols+1)*2)%8)
    2694           0 :         nBytes++;
    2695           0 :     pS->SeekRel(nBytes);
    2696           0 :     rRet += " matrix {\n";
    2697           0 :     int nRet = HandleRecords(nLevel+1,nSelector,nVariation,nRows,nCols);
    2698             : 
    2699           0 :     sal_Int32 nI = rRet.lastIndexOf('#');
    2700           0 :     if (nI > 0)
    2701           0 :         if (rRet[nI-1] != '#')  //missing column
    2702           0 :             rRet += "{}";
    2703             : 
    2704           0 :     rRet += "\n} ";
    2705           0 :     return nRet;
    2706             : }
    2707             : 
    2708          20 : int MathType::HandleTemplate(int nLevel,sal_uInt8 &rSelector,
    2709             :     sal_uInt8 &rVariation, sal_Int32 &rLastTemplateBracket)
    2710             : {
    2711             :     sal_uInt8 nOption; //This appears utterly unused
    2712          20 :     pS->ReadUChar( rSelector );
    2713          20 :     pS->ReadUChar( rVariation );
    2714          20 :     pS->ReadUChar( nOption );
    2715             :     OSL_ENSURE(rSelector < 48,"Selector out of range");
    2716          20 :     if ((rSelector >= 21) && (rSelector <=26))
    2717             :     {
    2718             :         OSL_ENSURE(nOption < 2,"Option out of range");
    2719             :     }
    2720           0 :     else if (/*(rSelector >= 0) &&*/ (rSelector <=12))
    2721             :     {
    2722             :         OSL_ENSURE(nOption < 3,"Option out of range");
    2723             :     }
    2724             : 
    2725             :     //For the (broken) case where one subscript template ends, and there is
    2726             :     //another one after it, mathtype handles it as if the second one was
    2727             :     //inside the first one and renders it as sub of sub
    2728          20 :     bool bRemove=false;
    2729          20 :     if ( (rSelector == 0xf) && (rLastTemplateBracket != -1) )
    2730             :     {
    2731           0 :         bRemove=true;
    2732           0 :         for (sal_Int32 nI = rLastTemplateBracket+1; nI < rRet.getLength(); nI++ )
    2733           0 :             if (rRet[nI] != ' ')
    2734             :             {
    2735           0 :                 bRemove=false;
    2736           0 :                 break;
    2737             :             }
    2738             :     }
    2739             : 
    2740             :     //suborderlist
    2741          20 :     int nRet = HandleRecords(nLevel+1,rSelector,rVariation);
    2742             : 
    2743          20 :     if (bRemove)
    2744             :     {
    2745           0 :         rRet = rRet.replaceAt(rLastTemplateBracket,1,"");
    2746           0 :         rRet += "} ";
    2747           0 :         rLastTemplateBracket = -1;
    2748             :     }
    2749          20 :     if (rSelector == 0xf)
    2750          20 :         rLastTemplateBracket = rRet.lastIndexOf('}');
    2751             :     else
    2752           0 :         rLastTemplateBracket = -1;
    2753             : 
    2754          20 :     rSelector = sal::static_int_cast< sal_uInt8 >(-1);
    2755          20 :     return nRet;
    2756             : }
    2757             : 
    2758           0 : void MathType::HandleEmblishments()
    2759             : {
    2760             :     sal_uInt8 nEmbel;
    2761           0 :     do
    2762             :     {
    2763           0 :         pS->ReadUChar( nEmbel );
    2764           0 :         switch (nEmbel)
    2765             :         {
    2766             :         case 0x02:
    2767           0 :             rRet += " dot ";
    2768           0 :             break;
    2769             :         case 0x03:
    2770           0 :             rRet += " ddot ";
    2771           0 :             break;
    2772             :         case 0x04:
    2773           0 :             rRet += " dddot ";
    2774           0 :             break;
    2775             :         case 0x05:
    2776           0 :             if (!nPostSup)
    2777             :             {
    2778           0 :                 sPost += " sup {}";
    2779           0 :                 nPostSup = sPost.getLength();
    2780             :             }
    2781           0 :             sPost = sPost.replaceAt(nPostSup-1,0," ' ");
    2782           0 :             nPostSup += 3;
    2783           0 :             break;
    2784             :         case 0x06:
    2785           0 :             if (!nPostSup)
    2786             :             {
    2787           0 :                 sPost += " sup {}";
    2788           0 :                 nPostSup = sPost.getLength();
    2789             :             }
    2790           0 :             sPost = sPost.replaceAt(nPostSup-1,0," '' ");
    2791           0 :             nPostSup += 4;
    2792           0 :             break;
    2793             :         case 0x07:
    2794           0 :             if (!nPostlSup)
    2795             :             {
    2796           0 :                 sPost += " lsup {}";
    2797           0 :                 nPostlSup = sPost.getLength();
    2798             :             }
    2799           0 :             sPost = sPost.replaceAt(nPostlSup-1,0," ' ");
    2800           0 :             nPostlSup += 3;
    2801           0 :             break;
    2802             :         case 0x08:
    2803           0 :             rRet += " tilde ";
    2804           0 :             break;
    2805             :         case 0x09:
    2806           0 :             rRet += " hat ";
    2807           0 :             break;
    2808             :         case 0x0b:
    2809           0 :             rRet += " vec ";
    2810           0 :             break;
    2811             :         case 0x10:
    2812           0 :             rRet += " overstrike ";
    2813           0 :             break;
    2814             :         case 0x11:
    2815           0 :             rRet += " bar ";
    2816           0 :             break;
    2817             :         case 0x12:
    2818           0 :             if (!nPostSup)
    2819             :             {
    2820           0 :                 sPost += " sup {}";
    2821           0 :                 nPostSup = sPost.getLength();
    2822             :             }
    2823           0 :             sPost = sPost.replaceAt(nPostSup-1,0," ''' ");
    2824           0 :             nPostSup += 5;
    2825           0 :             break;
    2826             :         case 0x14:
    2827           0 :             rRet += " breve ";
    2828           0 :             break;
    2829             :         default:
    2830             :             OSL_ENSURE(nEmbel < 21,"Embel out of range");
    2831           0 :             break;
    2832             :         }
    2833           0 :         if (nVersion < 3)
    2834           0 :             break;
    2835             :     }while (nEmbel);
    2836           0 : }
    2837             : 
    2838           0 : void MathType::HandleSetSize()
    2839             : {
    2840             :     sal_uInt8 nTemp;
    2841           0 :     pS->ReadUChar( nTemp );
    2842           0 :     switch (nTemp)
    2843             :     {
    2844             :         case 101:
    2845           0 :             pS->ReadInt16( nLSize );
    2846           0 :             nLSize = -nLSize;
    2847           0 :             break;
    2848             :         case 100:
    2849           0 :             pS->ReadUChar( nTemp );
    2850           0 :             nLSize = nTemp;
    2851           0 :             pS->ReadInt16( nDSize );
    2852           0 :             break;
    2853             :         default:
    2854           0 :             nLSize = nTemp;
    2855           0 :             pS->ReadUChar( nTemp );
    2856           0 :             nDSize = nTemp-128;
    2857           0 :             break;
    2858             :     }
    2859           0 : }
    2860             : 
    2861          48 : int MathType::HandleChar(sal_Int32 &rTextStart,int &rSetSize,int nLevel,
    2862             :     sal_uInt8 nTag,sal_uInt8 nSelector,sal_uInt8 nVariation, bool bSilent)
    2863             : {
    2864             :     sal_Unicode nChar;
    2865          48 :     int nRet=1;
    2866             : 
    2867          48 :     if (xfAUTO(nTag))
    2868             :     {
    2869             :     //This is a candidate for function recognition, whatever
    2870             :     //that is!
    2871             :     }
    2872             : 
    2873          48 :     sal_uInt8 nOldTypeFace = nTypeFace;
    2874          48 :     pS->ReadUChar( nTypeFace );
    2875          48 :     if (nVersion < 3)
    2876             :     {
    2877             :         sal_uInt8 nChar8;
    2878           0 :         pS->ReadUChar( nChar8 );
    2879           0 :         nChar = nChar8;
    2880             :     }
    2881             :     else
    2882          48 :         pS->ReadUInt16( nChar );
    2883             : 
    2884             :     /*
    2885             :     bad character, old mathtype < 3 has these
    2886             :     */
    2887          48 :     if (nChar < 0x20)
    2888           0 :         return nRet;
    2889             : 
    2890          48 :     if (xfEMBELL(nTag))
    2891             :     {
    2892             :         //A bit tricky, the character emblishments for
    2893             :         //mathtype can all be listed after eachother, in
    2894             :         //starmath some must go before the character and some
    2895             :         //must go after. In addition some of the emblishments
    2896             :         //may repeated and in starmath some of these groups
    2897             :         //must be gathered together. sPost is the portion that
    2898             :         //follows the char and nPostSup and nPostlSup are the
    2899             :         //indexes at which this class of emblishment is
    2900             :         //collated together
    2901           0 :         sPost = OUString();
    2902           0 :         nPostSup = nPostlSup = 0;
    2903           0 :         int nOriglen=rRet.getLength()-rTextStart;
    2904           0 :         rRet += " {";  // #i24340# make what would be "vec {A}_n" become "{vec {A}}_n"
    2905           0 :         if ((!bSilent) && ((nOriglen) > 1))
    2906           0 :             rRet += "\"";
    2907           0 :         nRet = HandleRecords(nLevel+1,nSelector,nVariation);
    2908           0 :         if (!bSilent)
    2909             :         {
    2910           0 :             if (nOriglen > 1)
    2911             :             {
    2912           0 :                 OUString aStr;
    2913           0 :                 TypeFaceToString(aStr,nOldTypeFace);
    2914           0 :                 aStr += "\"";
    2915           0 :                 rRet = rRet.replaceAt(rTextStart,0,aStr);
    2916             : 
    2917           0 :                 aStr = OUString();
    2918           0 :                 TypeFaceToString(aStr,nTypeFace);
    2919           0 :                 rRet += aStr + "{";
    2920             :             }
    2921             :             else
    2922           0 :                 rRet += " {";
    2923           0 :             rTextStart = rRet.getLength();
    2924             :         }
    2925             :     }
    2926             : 
    2927          48 :     if (!bSilent)
    2928             :     {
    2929          48 :         sal_Int32 nOldLen = rRet.getLength();
    2930          48 :         if (
    2931          96 :             HandleSize(nLSize,nDSize,rSetSize) ||
    2932          48 :             (nOldTypeFace != nTypeFace)
    2933             :            )
    2934             :         {
    2935          28 :             if ((nOldLen - rTextStart) > 1)
    2936             :             {
    2937           0 :                 rRet = rRet.replaceAt(nOldLen, 0, "\"");
    2938           0 :                 OUString aStr;
    2939           0 :                 TypeFaceToString(aStr,nOldTypeFace);
    2940           0 :                 aStr += "\"";
    2941           0 :                 rRet = rRet.replaceAt(rTextStart,0,aStr);
    2942             :             }
    2943          28 :             rTextStart = rRet.getLength();
    2944             :         }
    2945          48 :         nOldLen = rRet.getLength();
    2946          48 :         if (!LookupChar(nChar,rRet,nVersion,nTypeFace))
    2947             :         {
    2948           0 :             if (nOldLen - rTextStart > 1)
    2949             :             {
    2950           0 :                 rRet = rRet.replaceAt(nOldLen,0,"\"");
    2951           0 :                 OUString aStr;
    2952           0 :                 TypeFaceToString(aStr,nOldTypeFace);
    2953           0 :                 aStr += "\"";
    2954           0 :                 rRet = rRet.replaceAt(rTextStart, 0, aStr);
    2955             :             }
    2956           0 :             rTextStart = rRet.getLength();
    2957             :         }
    2958          48 :         lcl_PrependDummyTerm(rRet, rTextStart);
    2959             :     }
    2960             : 
    2961          48 :     if ((xfEMBELL(nTag)) && (!bSilent))
    2962             :     {
    2963           0 :         rRet += "}}" + sPost;  // #i24340# make what would be "vec {A}_n" become "{vec {A}}_n"
    2964           0 :         rTextStart = rRet.getLength();
    2965             :     }
    2966          48 :     return nRet;
    2967             : }
    2968             : 
    2969           0 : bool MathType::HandleLim(SmNode *pNode,int nLevel)
    2970             : {
    2971           0 :     bool bRet=false;
    2972             :     //Special case for the "lim" option in StarMath
    2973           0 :     if ((pNode->GetToken().eType == TLIM)
    2974           0 :         || (pNode->GetToken().eType == TLIMSUP)
    2975           0 :         || (pNode->GetToken().eType == TLIMINF)
    2976             :         )
    2977             :     {
    2978           0 :         if (pNode->GetSubNode(1))
    2979             :         {
    2980           0 :             sal_uInt8 nVariation2=HandleCScript(pNode->GetSubNode(0),NULL,
    2981           0 :                 nLevel);
    2982             : 
    2983           0 :             pS->WriteUChar( sal_uInt8(0x0A) );
    2984           0 :             pS->WriteUChar( sal_uInt8(LINE) ); //line
    2985           0 :             pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    2986           0 :             pS->WriteUChar( sal_uInt8(0x82) );
    2987           0 :             pS->WriteUInt16( sal_uInt16('l') );
    2988           0 :             pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    2989           0 :             pS->WriteUChar( sal_uInt8(0x82) );
    2990           0 :             pS->WriteUInt16( sal_uInt16('i') );
    2991           0 :             pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    2992           0 :             pS->WriteUChar( sal_uInt8(0x82) );
    2993           0 :             pS->WriteUInt16( sal_uInt16('m') );
    2994             : 
    2995           0 :             if (pNode->GetToken().eType == TLIMSUP)
    2996             :             {
    2997           0 :                 pS->WriteUChar( sal_uInt8(CHAR) ); //some space
    2998           0 :                 pS->WriteUChar( sal_uInt8(0x98) );
    2999           0 :                 pS->WriteUInt16( sal_uInt16(0xEB04) );
    3000             : 
    3001           0 :                 pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    3002           0 :                 pS->WriteUChar( sal_uInt8(0x82) );
    3003           0 :                 pS->WriteUInt16( sal_uInt16('s') );
    3004           0 :                 pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    3005           0 :                 pS->WriteUChar( sal_uInt8(0x82) );
    3006           0 :                 pS->WriteUInt16( sal_uInt16('u') );
    3007           0 :                 pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    3008           0 :                 pS->WriteUChar( sal_uInt8(0x82) );
    3009           0 :                 pS->WriteUInt16( sal_uInt16('p') );
    3010             :             }
    3011           0 :             else if (pNode->GetToken().eType == TLIMINF)
    3012             :             {
    3013           0 :                 pS->WriteUChar( sal_uInt8(CHAR) ); //some space
    3014           0 :                 pS->WriteUChar( sal_uInt8(0x98) );
    3015           0 :                 pS->WriteUInt16( sal_uInt16(0xEB04) );
    3016             : 
    3017           0 :                 pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    3018           0 :                 pS->WriteUChar( sal_uInt8(0x82) );
    3019           0 :                 pS->WriteUInt16( sal_uInt16('i') );
    3020           0 :                 pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    3021           0 :                 pS->WriteUChar( sal_uInt8(0x82) );
    3022           0 :                 pS->WriteUInt16( sal_uInt16('n') );
    3023           0 :                 pS->WriteUChar( sal_uInt8(CHAR|0x10) );
    3024           0 :                 pS->WriteUChar( sal_uInt8(0x82) );
    3025           0 :                 pS->WriteUInt16( sal_uInt16('f') );
    3026             :             }
    3027             : 
    3028             : 
    3029           0 :             pS->WriteUChar( sal_uInt8(CHAR) ); //some space
    3030           0 :             pS->WriteUChar( sal_uInt8(0x98) );
    3031           0 :             pS->WriteUInt16( sal_uInt16(0xEB04) );
    3032             : 
    3033           0 :             if (nVariation2 != 0xff)
    3034             :             {
    3035           0 :                 pS->WriteUChar( sal_uInt8(END) );
    3036           0 :                 pS->WriteUChar( sal_uInt8(END) );
    3037             :             }
    3038           0 :             HandleNodes(pNode->GetSubNode(1),nLevel+1);
    3039             :             //*pS << sal_uInt8(END); //options
    3040           0 :             bRet = true;
    3041             :         }
    3042             :     }
    3043           0 :     return bRet;
    3044             : }
    3045             : 
    3046           0 : void MathType::HandleMAlign(SmNode *pNode,int nLevel)
    3047             : {
    3048           0 :     sal_uInt8 nPushedHAlign=nHAlign;
    3049           0 :     switch(pNode->GetToken().eType)
    3050             :     {
    3051             :         case TALIGNC:
    3052           0 :             nHAlign=2;
    3053           0 :             break;
    3054             :         case TALIGNR:
    3055           0 :             nHAlign=3;
    3056           0 :             break;
    3057             :         default:
    3058           0 :             nHAlign=1;
    3059           0 :             break;
    3060             :     }
    3061           0 :     sal_uInt16  nSize = pNode->GetNumSubNodes();
    3062           0 :     for (sal_uInt16 i = 0; i < nSize; i++)
    3063           0 :         if (SmNode *pTemp = pNode->GetSubNode(i))
    3064           0 :             HandleNodes(pTemp,nLevel+1);
    3065           0 :     nHAlign=nPushedHAlign;
    3066           0 : }
    3067             : 
    3068           0 : void MathType::HandleMath(SmNode *pNode, int /*nLevel*/)
    3069             : {
    3070           0 :     if (pNode->GetToken().eType == TMLINE)
    3071             :     {
    3072           0 :         pS->WriteUChar( sal_uInt8(END) );
    3073           0 :         pS->WriteUChar( sal_uInt8(LINE) );
    3074           0 :         bIsReInterpBrace=true;
    3075           0 :         return;
    3076             :     }
    3077           0 :     SmMathSymbolNode *pTemp=(SmMathSymbolNode *)pNode;
    3078           0 :     for(sal_Int32 i=0;i<pTemp->GetText().getLength();i++)
    3079             :     {
    3080           0 :         sal_Unicode nArse = SmTextNode::ConvertSymbolToUnicode(pTemp->GetText()[i]);
    3081           0 :         if ((nArse == 0x2224) || (nArse == 0x2288) || (nArse == 0x2285) ||
    3082             :             (nArse == 0x2289))
    3083             :         {
    3084           0 :             pS->WriteUChar( sal_uInt8(CHAR|0x20) );
    3085             :         }
    3086           0 :         else if ((nPendingAttributes) &&
    3087           0 :                 (i == ((pTemp->GetText().getLength()+1)/2)-1))
    3088             :             {
    3089           0 :                 pS->WriteUChar( sal_uInt8(0x22) );
    3090             :             }
    3091             :         else
    3092           0 :             pS->WriteUChar( sal_uInt8(CHAR) ); //char without formula recognition
    3093             :         //The typeface seems to be MTEXTRA for unicode characters,
    3094             :         //though how to determine when mathtype chooses one over
    3095             :         //the other is unknown. This should do the trick
    3096             :         //nevertheless.
    3097             :         sal_uInt8 nBias;
    3098           0 :         if ( (nArse == 0x2213) || (nArse == 0x2218) ||
    3099           0 :             (nArse == 0x210F) || (
    3100           0 :                 (nArse >= 0x22EE) && (nArse <= 0x22FF)
    3101             :             ))
    3102             :         {
    3103           0 :             nBias = 0xB; //typeface
    3104             :         }
    3105           0 :         else if ((nArse > 0x2000) || (nArse == 0x00D7))
    3106           0 :             nBias = 0x6; //typeface
    3107           0 :         else if (nArse == 0x3d1)
    3108           0 :             nBias = 0x4;
    3109           0 :         else if ((nArse > 0xFF) && ((nArse < 0x393) || (nArse > 0x3c9)))
    3110           0 :             nBias = 0xB; //typeface
    3111           0 :         else if ((nArse == 0x2F) || (nArse == 0x2225))
    3112           0 :             nBias = 0x2; //typeface
    3113             :         else
    3114           0 :             nBias = 0x3; //typeface
    3115             : 
    3116           0 :         pS->WriteUChar( sal_uInt8(nSpec+nBias+128) ); //typeface
    3117             : 
    3118           0 :         if (nArse == 0x2224)
    3119             :         {
    3120           0 :             pS->WriteUInt16( sal_uInt16(0x7C) );
    3121           0 :             pS->WriteUChar( sal_uInt8(EMBEL) );
    3122           0 :             pS->WriteUChar( sal_uInt8(0x0A) );
    3123           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3124           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3125             :         }
    3126           0 :         else if (nArse == 0x2225)
    3127           0 :             pS->WriteUInt16( sal_uInt16(0xEC09) );
    3128           0 :         else if (nArse == 0xE421)
    3129           0 :             pS->WriteUInt16( sal_uInt16(0x2265) );
    3130           0 :         else if (nArse == 0x230A)
    3131           0 :             pS->WriteUInt16( sal_uInt16(0xF8F0) );
    3132           0 :         else if (nArse == 0x230B)
    3133           0 :             pS->WriteUInt16( sal_uInt16(0xF8FB) );
    3134           0 :         else if (nArse == 0xE425)
    3135           0 :             pS->WriteUInt16( sal_uInt16(0x2264) );
    3136           0 :         else if (nArse == 0x226A)
    3137             :         {
    3138           0 :             pS->WriteUInt16( sal_uInt16(0x3C) );
    3139           0 :             pS->WriteUChar( sal_uInt8(CHAR) );
    3140           0 :             pS->WriteUChar( sal_uInt8(0x98) );
    3141           0 :             pS->WriteUInt16( sal_uInt16(0xEB01) );
    3142           0 :             pS->WriteUChar( sal_uInt8(CHAR) );
    3143           0 :             pS->WriteUChar( sal_uInt8(0x86) );
    3144           0 :             pS->WriteUInt16( sal_uInt16(0x3c) );
    3145             :         }
    3146           0 :         else if (nArse == 0x2288)
    3147             :         {
    3148           0 :             pS->WriteUInt16( sal_uInt16(0x2286) );
    3149           0 :             pS->WriteUChar( sal_uInt8(EMBEL) );
    3150           0 :             pS->WriteUChar( sal_uInt8(0x0A) );
    3151           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3152           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3153             :         }
    3154           0 :         else if (nArse == 0x2289)
    3155             :         {
    3156           0 :             pS->WriteUInt16( sal_uInt16(0x2287) );
    3157           0 :             pS->WriteUChar( sal_uInt8(EMBEL) );
    3158           0 :             pS->WriteUChar( sal_uInt8(0x0A) );
    3159           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3160           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3161             :         }
    3162           0 :         else if (nArse == 0x2285)
    3163             :         {
    3164           0 :             pS->WriteUInt16( sal_uInt16(0x2283) );
    3165           0 :             pS->WriteUChar( sal_uInt8(EMBEL) );
    3166           0 :             pS->WriteUChar( sal_uInt8(0x0A) );
    3167           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3168           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3169             :         }
    3170             :         else
    3171           0 :             pS->WriteUInt16( nArse );
    3172             :     }
    3173           0 :     nPendingAttributes = 0;
    3174             : }
    3175             : 
    3176           0 : void MathType::HandleAttributes(SmNode *pNode,int nLevel)
    3177             : {
    3178           0 :     int nOldPending = 0;
    3179           0 :     SmNode *pTemp       = 0;
    3180           0 :     SmTextNode *pIsText = 0;
    3181             : 
    3182           0 :     if (NULL != (pTemp = pNode->GetSubNode(0)))
    3183             :     {
    3184           0 :         pIsText = (SmTextNode *)pNode->GetSubNode(1);
    3185             : 
    3186           0 :         switch (pTemp->GetToken().eType)
    3187             :         {
    3188             :         case TWIDEVEC:
    3189             :             //theres just no way we can now handle any character
    3190             :             //attributes (from mathtypes perspective) centered
    3191             :             //over an expression but above template attributes
    3192             :             //such as widevec and similar constructs
    3193             :             //we have to drop them
    3194           0 :             nOldPending = StartTemplate(0x2f,0x01);
    3195           0 :             break;
    3196             :         case TCHECK: //Not Exportable
    3197             :         case TACUTE: //Not Exportable
    3198             :         case TGRAVE: //Not Exportable
    3199             :         case TCIRCLE: //Not Exportable
    3200             :         case TWIDETILDE: //Not Exportable
    3201             :         case TWIDEHAT: //Not Exportable
    3202           0 :             break;
    3203             :         case TUNDERLINE:
    3204           0 :             nOldPending = StartTemplate(0x10);
    3205           0 :             break;
    3206             :         case TOVERLINE: //If the next node is not text
    3207             :                         //or text with more than one char
    3208           0 :             if ((pIsText->GetToken().eType != TTEXT) ||
    3209           0 :                 (pIsText->GetText().getLength() > 1))
    3210           0 :                 nOldPending = StartTemplate(0x11);
    3211           0 :             break;
    3212             :         default:
    3213           0 :             nPendingAttributes++;
    3214           0 :             break;
    3215             :         }
    3216             :     }
    3217             : 
    3218           0 :     if (pIsText)
    3219           0 :         HandleNodes(pIsText,nLevel+1);
    3220             : 
    3221           0 :     switch (pTemp->GetToken().eType)
    3222             :     {
    3223             :         case TWIDEVEC:
    3224             :         case TUNDERLINE:
    3225           0 :             EndTemplate(nOldPending);
    3226           0 :             break;
    3227             :         case TOVERLINE:
    3228           0 :             if ((pIsText->GetToken().eType != TTEXT) ||
    3229           0 :                 (pIsText->GetText().getLength() > 1))
    3230           0 :                 EndTemplate(nOldPending);
    3231           0 :             break;
    3232             :         default:
    3233           0 :             break;
    3234             :     }
    3235             : 
    3236             :     //if there was no suitable place to put the attribute,
    3237             :     //then we have to just give up on it
    3238           0 :     if (nPendingAttributes)
    3239           0 :         nPendingAttributes--;
    3240             :     else
    3241             :     {
    3242           0 :         if ((nInsertion != 0) && NULL != (pTemp = pNode->GetSubNode(0)))
    3243             :         {
    3244           0 :             sal_uLong nPos = pS->Tell();
    3245           0 :             nInsertion--;
    3246           0 :             pS->Seek(nInsertion);
    3247           0 :             switch(pTemp->GetToken().eType)
    3248             :             {
    3249             :             case TACUTE: //Not Exportable
    3250             :             case TGRAVE: //Not Exportable
    3251             :             case TCIRCLE: //Not Exportable
    3252           0 :                 break;
    3253             :             case TCDOT:
    3254           0 :                 pS->WriteUChar( sal_uInt8(2) );
    3255           0 :                 break;
    3256             :             case TDDOT:
    3257           0 :                 pS->WriteUChar( sal_uInt8(3) );
    3258           0 :                 break;
    3259             :             case TDDDOT:
    3260           0 :                 pS->WriteUChar( sal_uInt8(4) );
    3261           0 :                 break;
    3262             :             case TTILDE:
    3263           0 :                 pS->WriteUChar( sal_uInt8(8) );
    3264           0 :                 break;
    3265             :             case THAT:
    3266           0 :                 pS->WriteUChar( sal_uInt8(9) );
    3267           0 :                 break;
    3268             :             case TVEC:
    3269           0 :                 pS->WriteUChar( sal_uInt8(11) );
    3270           0 :                 break;
    3271             :             case TOVERSTRIKE:
    3272           0 :                 pS->WriteUChar( sal_uInt8(16) );
    3273           0 :                 break;
    3274             :             case TOVERLINE:
    3275           0 :                 if ((pIsText->GetToken().eType == TTEXT) &&
    3276           0 :                     (pIsText->GetText().getLength() == 1))
    3277           0 :                     pS->WriteUChar( sal_uInt8(17) );
    3278           0 :                 break;
    3279             :             case TBREVE:
    3280           0 :                 pS->WriteUChar( sal_uInt8(20) );
    3281           0 :                 break;
    3282             :             case TWIDEVEC:
    3283             :             case TUNDERLINE:
    3284             :             case TWIDETILDE:
    3285             :             case TWIDEHAT:
    3286           0 :                 break;
    3287             :             case TBAR:
    3288           0 :                 pS->WriteUChar( sal_uInt8(17) );
    3289           0 :                 break;
    3290             :             default:
    3291           0 :                 pS->WriteUChar( sal_uInt8(0x2) );
    3292           0 :                 break;
    3293             :             }
    3294           0 :         pS->Seek(nPos);
    3295             :         }
    3296             :     }
    3297           0 : }
    3298             : 
    3299           0 : void MathType::HandleText(SmNode *pNode, int /*nLevel*/)
    3300             : {
    3301           0 :     SmTextNode *pTemp=(SmTextNode *)pNode;
    3302           0 :     for(sal_Int32 i=0;i<pTemp->GetText().getLength();i++)
    3303             :     {
    3304           0 :         if ((nPendingAttributes) &&
    3305           0 :             (i == ((pTemp->GetText().getLength()+1)/2)-1))
    3306             :         {
    3307           0 :             pS->WriteUChar( sal_uInt8(0x22) );     //char, with attributes right
    3308             :                                 //after the character
    3309             :         }
    3310             :         else
    3311           0 :             pS->WriteUChar( sal_uInt8(CHAR) );
    3312             : 
    3313           0 :         sal_uInt8 nFace = 0x1;
    3314           0 :         if (pNode->GetFont().GetItalic() == ITALIC_NORMAL)
    3315           0 :             nFace = 0x3;
    3316           0 :         else if (pNode->GetFont().GetWeight() == WEIGHT_BOLD)
    3317           0 :             nFace = 0x7;
    3318           0 :         pS->WriteUChar( sal_uInt8(nFace+128) ); //typeface
    3319           0 :         sal_uInt16 nChar = pTemp->GetText()[i];
    3320           0 :         pS->WriteUInt16( SmTextNode::ConvertSymbolToUnicode(nChar) );
    3321             : 
    3322             :         //Mathtype can only have these sort of character
    3323             :         //attributes on a single character, starmath can put them
    3324             :         //anywhere, when the entity involved is a text run this is
    3325             :         //a large effort to place the character attribute on the
    3326             :         //central mathtype character so that it does pretty much
    3327             :         //what the user probably has in mind. The attributes
    3328             :         //filled in here are dummy ones which are replaced in the
    3329             :         //ATTRIBUT handler if a suitable location for the
    3330             :         //attributes was found here. Unfortunately it is
    3331             :         //possible for starmath to place character attributes on
    3332             :         //entities which cannot occur in mathtype e.g. a Summation
    3333             :         //symbol so these attributes may be lost
    3334           0 :         if ((nPendingAttributes) &&
    3335           0 :             (i == ((pTemp->GetText().getLength()+1)/2)-1))
    3336             :         {
    3337           0 :             pS->WriteUChar( sal_uInt8(EMBEL) );
    3338           0 :             while (nPendingAttributes)
    3339             :             {
    3340           0 :                 pS->WriteUChar( sal_uInt8(2) );
    3341             :                 //wedge the attributes in here and clear
    3342             :                 //the pending stack
    3343           0 :                 nPendingAttributes--;
    3344             :             }
    3345           0 :             nInsertion=pS->Tell();
    3346           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3347           0 :             pS->WriteUChar( sal_uInt8(END) ); //end embel
    3348             :         }
    3349             :     }
    3350          72 : }
    3351             : 
    3352             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10