Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * Version: MPL 1.1 / GPLv3+ / LGPLv3+
4 : *
5 : * The contents of this file are subject to the Mozilla Public License Version
6 : * 1.1 (the "License"); you may not use this file except in compliance with
7 : * the License or as specified alternatively below. You may obtain a copy of
8 : * the License at http://www.mozilla.org/MPL/
9 : *
10 : * Software distributed under the License is distributed on an "AS IS" basis,
11 : * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12 : * for the specific language governing rights and limitations under the
13 : * License.
14 : *
15 : * Major Contributor(s):
16 : * Copyright (C) 2011 Lubos Lunak <l.lunak@suse.cz> (initial developer)
17 : *
18 : * All Rights Reserved.
19 : *
20 : * For minor contributions see the git repository.
21 : *
22 : * Alternatively, the contents of this file may be used under the terms of
23 : * either the GNU General Public License Version 3 or later (the "GPLv3+"), or
24 : * the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"),
25 : * in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable
26 : * instead of those above.
27 : */
28 :
29 :
30 : #include "ooxmlimport.hxx"
31 :
32 : #include <oox/token/tokens.hxx>
33 : #include <oox/token/namespaces.hxx>
34 : #include <rtl/ustring.hxx>
35 :
36 : using namespace oox;
37 : using namespace oox::formulaimport;
38 :
39 : /*
40 : The primary internal data structure for the formula is the text representation
41 : (the SmNode tree is built from it), so read data must be converted into this format.
42 : */
43 :
44 : #define M_TOKEN( token ) OOX_TOKEN( officeMath, token )
45 : #define OPENING( token ) XML_STREAM_OPENING( token )
46 : #define CLOSING( token ) XML_STREAM_CLOSING( token )
47 :
48 : // TODO create IS_OPENING(), IS_CLOSING() instead of doing 'next == OPENING( next )' ?
49 :
50 284 : SmOoxmlImport::SmOoxmlImport( oox::formulaimport::XmlStream& s )
51 284 : : stream( s )
52 : {
53 284 : }
54 :
55 284 : OUString SmOoxmlImport::ConvertToStarMath()
56 : {
57 284 : return handleStream();
58 : }
59 :
60 : // "toplevel" of reading, there will be oMath (if there was oMathPara, that was
61 : // up to the parent component to handle)
62 :
63 : // NOT complete
64 284 : OUString SmOoxmlImport::handleStream()
65 : {
66 284 : stream.ensureOpeningTag( M_TOKEN( oMath ));
67 284 : OUString ret;
68 852 : while( !stream.atEnd() && stream.currentToken() != CLOSING( M_TOKEN( oMath )))
69 : {
70 : // strictly speaking, it is not OMathArg here, but currently supported
71 : // functionality is the same like OMathArg, in the future this may need improving
72 284 : OUString item = readOMathArg();
73 284 : if( item.isEmpty())
74 0 : continue;
75 284 : if( !ret.isEmpty())
76 0 : ret += " ";
77 284 : ret += item;
78 284 : }
79 284 : stream.ensureClosingTag( M_TOKEN( oMath ));
80 : // Placeholders are written out as nothing (i.e. nothing inside e.g. the <e> element),
81 : // which will result in "{}" in the formula text. Fix this up.
82 284 : ret = ret.replaceAll( "{}", "<?>" );
83 : // And as a result, empty parts of the formula that are not placeholders are written out
84 : // as a single space, so fix that up too.
85 284 : ret = ret.replaceAll( "{ }", "{}" );
86 : SAL_INFO( "starmath.ooxml", "Formula: " << ret );
87 284 : return ret;
88 : }
89 :
90 1748 : OUString SmOoxmlImport::readOMathArg()
91 : {
92 1748 : OUString ret;
93 6188 : while( !stream.atEnd() && stream.currentToken() != CLOSING( stream.currentToken()))
94 : {
95 2692 : if( !ret.isEmpty())
96 1000 : ret += " ";
97 2692 : switch( stream.currentToken())
98 : {
99 : case OPENING( M_TOKEN( acc )):
100 96 : ret += handleAcc();
101 96 : break;
102 : case OPENING( M_TOKEN( bar )):
103 8 : ret += handleBar();
104 8 : break;
105 : case OPENING( M_TOKEN( box )):
106 2 : ret += handleBox();
107 2 : break;
108 : case OPENING( M_TOKEN( borderBox )):
109 8 : ret += handleBorderBox();
110 8 : break;
111 : case OPENING( M_TOKEN( d )):
112 174 : ret += handleD();
113 174 : break;
114 : case OPENING( M_TOKEN( eqArr )):
115 20 : ret += handleEqArr();
116 20 : break;
117 : case OPENING( M_TOKEN( f )):
118 136 : ret += handleF();
119 136 : break;
120 : case OPENING( M_TOKEN( func )):
121 48 : ret += handleFunc();
122 48 : break;
123 : case OPENING( M_TOKEN( limLow )):
124 24 : ret += handleLimLowUpp( LimLow );
125 24 : break;
126 : case OPENING( M_TOKEN( limUpp )):
127 16 : ret += handleLimLowUpp( LimUpp );
128 16 : break;
129 : case OPENING( M_TOKEN( groupChr )):
130 16 : ret += handleGroupChr();
131 16 : break;
132 : case OPENING( M_TOKEN( m )):
133 8 : ret += handleM();
134 8 : break;
135 : case OPENING( M_TOKEN( nary )):
136 48 : ret += handleNary();
137 48 : break;
138 : case OPENING( M_TOKEN( r )):
139 1868 : ret += handleR();
140 1868 : break;
141 : case OPENING( M_TOKEN( rad )):
142 24 : ret += handleRad();
143 24 : break;
144 : case OPENING( M_TOKEN( sPre )):
145 16 : ret += handleSpre();
146 16 : break;
147 : case OPENING( M_TOKEN( sSub )):
148 32 : ret += handleSsub();
149 32 : break;
150 : case OPENING( M_TOKEN( sSubSup )):
151 16 : ret += handleSsubsup();
152 16 : break;
153 : case OPENING( M_TOKEN( sSup )):
154 132 : ret += handleSsup();
155 132 : break;
156 : default:
157 0 : stream.handleUnexpectedTag();
158 0 : break;
159 : }
160 : }
161 1748 : return ret;
162 : }
163 :
164 1464 : OUString SmOoxmlImport::readOMathArgInElement( int token )
165 : {
166 1464 : stream.ensureOpeningTag( token );
167 1464 : OUString ret = readOMathArg();
168 1464 : stream.ensureClosingTag( token );
169 1464 : return ret;
170 : }
171 :
172 96 : OUString SmOoxmlImport::handleAcc()
173 : {
174 96 : stream.ensureOpeningTag( M_TOKEN( acc ));
175 96 : sal_Unicode accChr = 0x302;
176 96 : if( XmlStream::Tag accPr = stream.checkOpeningTag( M_TOKEN( accPr )))
177 : {
178 96 : if( XmlStream::Tag chr = stream.checkOpeningTag( M_TOKEN( chr )))
179 : {
180 94 : accChr = chr.attribute( M_TOKEN( val ), accChr );
181 94 : stream.ensureClosingTag( M_TOKEN( chr ));
182 96 : }
183 96 : stream.ensureClosingTag( M_TOKEN( accPr ));
184 96 : }
185 : // see aTokenTable in parse.cxx
186 96 : OUString acc;
187 96 : switch( accChr )
188 : {
189 : case MS_BAR:
190 0 : acc = "bar";
191 0 : break;
192 : case MS_CHECK:
193 8 : acc = "check";
194 8 : break;
195 : case MS_ACUTE:
196 8 : acc = "acute";
197 8 : break;
198 : case MS_GRAVE:
199 8 : acc = "grave";
200 8 : break;
201 : case MS_BREVE:
202 8 : acc = "breve";
203 8 : break;
204 : case MS_CIRCLE:
205 8 : acc = "circle";
206 8 : break;
207 : case MS_VEC:
208 : // prefer wide variants for these 3, .docx can't seem to differentiate
209 : // between e.g. 'vec' and 'widevec', if whatever the accent is above is short, this
210 : // shouldn't matter, but short above a longer expression doesn't look right
211 24 : acc = "widevec";
212 24 : break;
213 : case MS_TILDE:
214 16 : acc = "widetilde";
215 16 : break;
216 : case MS_HAT:
217 8 : acc = "widehat";
218 8 : break;
219 : case MS_DOT:
220 8 : acc = "dot";
221 8 : break;
222 : case MS_DDOT:
223 0 : acc = "ddot";
224 0 : break;
225 : case MS_DDDOT:
226 0 : acc = "dddot";
227 0 : break;
228 : default:
229 0 : acc = "acute";
230 : SAL_WARN( "starmath.ooxml", "Unknown m:chr in m:acc \'" << accChr << "\'" );
231 0 : break;
232 : }
233 96 : OUString e = readOMathArgInElement( M_TOKEN( e ));
234 96 : stream.ensureClosingTag( M_TOKEN( acc ));
235 96 : return acc + " {" + e + "}";
236 : }
237 :
238 8 : OUString SmOoxmlImport::handleBar()
239 : {
240 8 : stream.ensureOpeningTag( M_TOKEN( bar ));
241 8 : enum pos_t { top, bot } topbot = bot;
242 8 : if( stream.checkOpeningTag( M_TOKEN( barPr )))
243 : {
244 8 : if( XmlStream::Tag pos = stream.checkOpeningTag( M_TOKEN( pos )))
245 : {
246 6 : if( pos.attribute( M_TOKEN( val )) == "top" )
247 0 : topbot = top;
248 6 : else if( pos.attribute( M_TOKEN( val )) == "bot" )
249 6 : topbot = bot;
250 6 : stream.ensureClosingTag( M_TOKEN( pos ));
251 8 : }
252 8 : stream.ensureClosingTag( M_TOKEN( barPr ));
253 : }
254 8 : OUString e = readOMathArgInElement( M_TOKEN( e ));
255 8 : stream.ensureClosingTag( M_TOKEN( bar ));
256 8 : if( topbot == top )
257 0 : return "overline {" + e + "}";
258 : else
259 8 : return "underline {" + e + "}";
260 : }
261 :
262 2 : OUString SmOoxmlImport::handleBox()
263 : {
264 : // there does not seem to be functionality in LO to actually implement this
265 : // (or is there), but at least read in the contents instead of ignoring them
266 2 : stream.ensureOpeningTag( M_TOKEN( box ));
267 2 : OUString e = readOMathArgInElement( M_TOKEN( e ));
268 2 : stream.ensureClosingTag( M_TOKEN( box ));
269 2 : return e;
270 : }
271 :
272 :
273 8 : OUString SmOoxmlImport::handleBorderBox()
274 : {
275 8 : stream.ensureOpeningTag( M_TOKEN( borderBox ));
276 8 : bool isStrikeH = false;
277 8 : if( stream.checkOpeningTag( M_TOKEN( borderBoxPr )))
278 : {
279 8 : if( XmlStream::Tag strikeH = stream.checkOpeningTag( M_TOKEN( strikeH )))
280 : {
281 8 : if( strikeH.attribute( M_TOKEN( val ), false ))
282 8 : isStrikeH = true;
283 8 : stream.ensureClosingTag( M_TOKEN( strikeH ));
284 8 : }
285 8 : stream.ensureClosingTag( M_TOKEN( borderBoxPr ));
286 : }
287 8 : OUString e = readOMathArgInElement( M_TOKEN( e ));
288 8 : stream.ensureClosingTag( M_TOKEN( borderBox ));
289 8 : if( isStrikeH )
290 8 : return "overstrike {" + e + "}";
291 : // LO does not seem to implement anything for handling the other cases
292 0 : return e;
293 : }
294 :
295 174 : OUString SmOoxmlImport::handleD()
296 : {
297 174 : stream.ensureOpeningTag( M_TOKEN( d ));
298 174 : OUString opening = "(";
299 174 : OUString closing = ")";
300 174 : OUString separator = "|";
301 174 : if( XmlStream::Tag dPr = stream.checkOpeningTag( M_TOKEN( dPr )))
302 : {
303 174 : if( XmlStream::Tag begChr = stream.checkOpeningTag( M_TOKEN( begChr )))
304 : {
305 128 : opening = begChr.attribute( M_TOKEN( val ), opening );
306 128 : stream.ensureClosingTag( M_TOKEN( begChr ));
307 174 : }
308 174 : if( XmlStream::Tag sepChr = stream.checkOpeningTag( M_TOKEN( sepChr )))
309 : {
310 14 : separator = sepChr.attribute( M_TOKEN( val ), separator );
311 14 : stream.ensureClosingTag( M_TOKEN( sepChr ));
312 174 : }
313 174 : if( XmlStream::Tag endChr = stream.checkOpeningTag( M_TOKEN( endChr )))
314 : {
315 128 : closing = endChr.attribute( M_TOKEN( val ), closing );
316 128 : stream.ensureClosingTag( M_TOKEN( endChr ));
317 174 : }
318 174 : stream.ensureClosingTag( M_TOKEN( dPr ));
319 174 : }
320 174 : if( opening == "{" )
321 4 : opening = "left lbrace ";
322 174 : if( closing == "}" )
323 0 : closing = " right rbrace";
324 174 : if( opening == OUString( sal_Unicode( 0x27e6 )))
325 8 : opening = "left ldbracket ";
326 174 : if( closing == OUString( sal_Unicode( 0x27e7 )))
327 8 : closing = " right rdbracket";
328 174 : if( opening == "|" )
329 8 : opening = "left lline ";
330 174 : if( closing == "|" )
331 8 : closing = " right rline";
332 174 : if( opening == OUString( sal_Unicode( 0x2225 )))
333 8 : opening = "left ldline ";
334 174 : if( closing == OUString( sal_Unicode( 0x2225 )))
335 8 : closing = " right rdline";
336 174 : if( opening == OUString( sal_Unicode( 0x2329 )))
337 16 : opening = "left langle ";
338 174 : if( closing == OUString( sal_Unicode( 0x232a )))
339 16 : closing = " right rangle";
340 : // use scalable brackets (the explicit "left" or "right")
341 174 : if( opening == "(" || opening == "[" )
342 128 : opening = "left " + opening;
343 174 : if( closing == ")" || closing == "]" )
344 128 : closing = " right " + closing;
345 174 : if( separator == "|" ) // plain "|" would be actually "V" (logical or)
346 172 : separator = " mline ";
347 174 : if( opening.isEmpty())
348 0 : opening = "left none ";
349 174 : if( closing.isEmpty())
350 4 : closing = " right none";
351 174 : OUStringBuffer ret;
352 174 : ret.append( opening );
353 174 : bool first = true;
354 542 : while( stream.findTag( OPENING( M_TOKEN( e ))))
355 : {
356 194 : if( !first )
357 28 : ret.append( separator );
358 194 : first = false;
359 194 : ret.append( readOMathArgInElement( M_TOKEN( e )));
360 : }
361 174 : ret.append( closing );
362 174 : stream.ensureClosingTag( M_TOKEN( d ));
363 174 : return ret.makeStringAndClear();
364 : }
365 :
366 20 : OUString SmOoxmlImport::handleEqArr()
367 : {
368 20 : stream.ensureOpeningTag( M_TOKEN( eqArr ));
369 20 : OUString ret;
370 88 : do
371 : { // there must be at least one m:e
372 44 : if( !ret.isEmpty())
373 24 : ret += "#";
374 44 : ret += " ";
375 44 : ret += readOMathArgInElement( M_TOKEN( e ));
376 44 : ret += " ";
377 88 : } while( !stream.atEnd() && stream.findTag( OPENING( M_TOKEN( e ))));
378 20 : stream.ensureClosingTag( M_TOKEN( eqArr ));
379 20 : return "stack {" + ret + "}";
380 : }
381 :
382 136 : OUString SmOoxmlImport::handleF()
383 : {
384 136 : stream.ensureOpeningTag( M_TOKEN( f ));
385 136 : enum operation_t { bar, lin, noBar } operation = bar;
386 136 : if( stream.checkOpeningTag( M_TOKEN( fPr )))
387 : {
388 76 : if( XmlStream::Tag type = stream.checkOpeningTag( M_TOKEN( type )))
389 : {
390 24 : if( type.attribute( M_TOKEN( val )) == "bar" )
391 0 : operation = bar;
392 24 : else if( type.attribute( M_TOKEN( val )) == "lin" )
393 8 : operation = lin;
394 16 : else if( type.attribute( M_TOKEN( val )) == "noBar" )
395 16 : operation = noBar;
396 24 : stream.ensureClosingTag( M_TOKEN( type ));
397 76 : }
398 76 : stream.ensureClosingTag( M_TOKEN( fPr ));
399 : }
400 136 : OUString num = readOMathArgInElement( M_TOKEN( num ));
401 136 : OUString den = readOMathArgInElement( M_TOKEN( den ));
402 136 : stream.ensureClosingTag( M_TOKEN( f ));
403 136 : if( operation == bar )
404 112 : return "{" + num + "} over {" + den + "}";
405 24 : else if( operation == lin )
406 8 : return "{" + num + "} / {" + den + "}";
407 : else // noBar
408 : {
409 16 : return "binom {" + num + "} {" + den + "}";
410 136 : }
411 : }
412 :
413 48 : OUString SmOoxmlImport::handleFunc()
414 : {
415 : //lim from{x rightarrow 1} x
416 48 : stream.ensureOpeningTag( M_TOKEN( func ));
417 48 : OUString fname = readOMathArgInElement( M_TOKEN( fName ));
418 : // fix the various functions
419 48 : if( fname.startsWith( "lim csub {" ))
420 8 : fname = "lim from {" + fname.copy( 10 );
421 48 : OUString ret = fname + " {" + readOMathArgInElement( M_TOKEN( e )) + "}";
422 48 : stream.ensureClosingTag( M_TOKEN( func ));
423 48 : return ret;
424 : }
425 :
426 40 : OUString SmOoxmlImport::handleLimLowUpp( LimLowUpp_t limlowupp )
427 : {
428 40 : int token = limlowupp == LimLow ? M_TOKEN( limLow ) : M_TOKEN( limUpp );
429 40 : stream.ensureOpeningTag( token );
430 40 : OUString e = readOMathArgInElement( M_TOKEN( e ));
431 40 : OUString lim = readOMathArgInElement( M_TOKEN( lim ));
432 40 : stream.ensureClosingTag( token );
433 : // fix up overbrace/underbrace (use { }, as {} will be converted to a placeholder)
434 40 : if( limlowupp == LimUpp && e.endsWith( " overbrace { }" ))
435 8 : return e.copy( 0, e.getLength() - 2 ) + lim + "}";
436 32 : if( limlowupp == LimLow && e.endsWith( " underbrace { }" ))
437 8 : return e.copy( 0, e.getLength() - 2 ) + lim + "}";
438 : return e
439 48 : + ( limlowupp == LimLow ? OUString( " csub {" ) : OUString( " csup {" ))
440 64 : + lim + "}";
441 : }
442 :
443 16 : OUString SmOoxmlImport::handleGroupChr()
444 : {
445 16 : stream.ensureOpeningTag( M_TOKEN( groupChr ));
446 16 : sal_Unicode chr = 0x23df;
447 16 : enum pos_t { top, bot } pos = bot;
448 16 : if( stream.checkOpeningTag( M_TOKEN( groupChrPr )))
449 : {
450 16 : if( XmlStream::Tag chrTag = stream.checkOpeningTag( M_TOKEN( chr )))
451 : {
452 14 : chr = chrTag.attribute( M_TOKEN( val ), chr );
453 14 : stream.ensureClosingTag( M_TOKEN( chr ));
454 16 : }
455 16 : if( XmlStream::Tag posTag = stream.checkOpeningTag( M_TOKEN( pos )))
456 : {
457 14 : if( posTag.attribute( M_TOKEN( val ), OUString( "bot" )) == "top" )
458 8 : pos = top;
459 14 : stream.ensureClosingTag( M_TOKEN( pos ));
460 16 : }
461 16 : stream.ensureClosingTag( M_TOKEN( groupChrPr ));
462 : }
463 16 : OUString e = readOMathArgInElement( M_TOKEN( e ));
464 16 : stream.ensureClosingTag( M_TOKEN( groupChr ));
465 16 : if( pos == top && chr == sal_Unicode( 0x23de ))
466 8 : return "{" + e + "} overbrace { }";
467 8 : if( pos == bot && chr == sal_Unicode( 0x23df ))
468 8 : return "{" + e + "} underbrace { }";
469 0 : if( pos == top )
470 0 : return "{" + e + "} csup {" + OUString( chr ) + "}";
471 : else
472 0 : return "{" + e + "} csub {" + OUString( chr ) + "}";
473 : }
474 :
475 8 : OUString SmOoxmlImport::handleM()
476 : {
477 8 : stream.ensureOpeningTag( M_TOKEN( m ));
478 8 : OUString allrows;
479 32 : do // there must be at least one m:mr
480 : {
481 16 : stream.ensureOpeningTag( M_TOKEN( mr ));
482 16 : OUString row;
483 64 : do // there must be at least one m:e
484 : {
485 32 : if( !row.isEmpty())
486 16 : row += " # ";
487 32 : row += readOMathArgInElement( M_TOKEN( e ));
488 64 : } while( !stream.atEnd() && stream.findTag( OPENING( M_TOKEN( e ))));
489 16 : if( !allrows.isEmpty())
490 8 : allrows += " ## ";
491 16 : allrows += row;
492 16 : stream.ensureClosingTag( M_TOKEN( mr ));
493 32 : } while( !stream.atEnd() && stream.findTag( OPENING( M_TOKEN( mr ))));
494 8 : stream.ensureClosingTag( M_TOKEN( m ));
495 8 : return "matrix {" + allrows + "}";
496 : }
497 :
498 48 : OUString SmOoxmlImport::handleNary()
499 : {
500 48 : stream.ensureOpeningTag( M_TOKEN( nary ));
501 48 : sal_Unicode chr = 0x222b;
502 48 : bool subHide = false;
503 48 : bool supHide = false;
504 48 : if( stream.checkOpeningTag( M_TOKEN( naryPr )))
505 : {
506 48 : if( XmlStream::Tag chrTag = stream.checkOpeningTag( M_TOKEN( chr )))
507 : {
508 48 : chr = chrTag.attribute( M_TOKEN( val ), chr );
509 48 : stream.ensureClosingTag( M_TOKEN( chr ));
510 48 : }
511 48 : if( XmlStream::Tag subHideTag = stream.checkOpeningTag( M_TOKEN( subHide )))
512 : {
513 8 : subHide = subHideTag.attribute( M_TOKEN( val ), subHide );
514 8 : stream.ensureClosingTag( M_TOKEN( subHide ));
515 48 : }
516 48 : if( XmlStream::Tag supHideTag = stream.checkOpeningTag( M_TOKEN( supHide )))
517 : {
518 8 : supHide = supHideTag.attribute( M_TOKEN( val ), supHide );
519 8 : stream.ensureClosingTag( M_TOKEN( supHide ));
520 48 : }
521 48 : stream.ensureClosingTag( M_TOKEN( naryPr ));
522 : }
523 48 : OUString sub = readOMathArgInElement( M_TOKEN( sub ));
524 48 : OUString sup = readOMathArgInElement( M_TOKEN( sup ));
525 48 : OUString e = readOMathArgInElement( M_TOKEN( e ));
526 48 : OUString ret;
527 48 : switch( chr )
528 : {
529 : case MS_INT:
530 0 : ret = "int";
531 0 : break;
532 : case MS_IINT:
533 0 : ret = "liint";
534 0 : break;
535 : case MS_IIINT:
536 0 : ret = "liiint";
537 0 : break;
538 : case MS_LINT:
539 0 : ret = "lint";
540 0 : break;
541 : case MS_LLINT:
542 0 : ret = "llint";
543 0 : break;
544 : case MS_LLLINT:
545 8 : ret = "lllint";
546 8 : break;
547 : case MS_PROD:
548 8 : ret = "prod";
549 8 : break;
550 : case MS_COPROD:
551 0 : ret = "coprod";
552 0 : break;
553 : case MS_SUM:
554 32 : ret = "sum";
555 32 : break;
556 : default:
557 : SAL_WARN( "starmath.ooxml", "Unknown m:nary chr \'" << chr << "\'" );
558 0 : break;
559 : }
560 48 : if( !subHide )
561 40 : ret += " from {" + sub + "}";
562 48 : if( !supHide )
563 40 : ret += " to {" + sup + "}";
564 48 : ret += " {" + e + "}";
565 48 : stream.ensureClosingTag( M_TOKEN( nary ));
566 48 : return ret;
567 : }
568 :
569 : // NOT complete
570 1868 : OUString SmOoxmlImport::handleR()
571 : {
572 1868 : stream.ensureOpeningTag( M_TOKEN( r ));
573 1868 : if( XmlStream::Tag rPr = stream.checkOpeningTag( OOX_TOKEN( doc, rPr )))
574 : { // TODO
575 : // stream.checkOpeningTag( OOX_TOKEN( doc, rFonts ));
576 : // stream.ensureClosingTag( OOX_TOKEN( doc, rFonts ));
577 338 : stream.ensureClosingTag( OOX_TOKEN( doc, rPr ));
578 1868 : }
579 1868 : OUString text;
580 5604 : while( !stream.atEnd() && stream.currentToken() != CLOSING( stream.currentToken()))
581 : {
582 1868 : switch( stream.currentToken())
583 : {
584 : case OPENING( M_TOKEN( t )):
585 : {
586 1868 : XmlStream::Tag rtag = stream.ensureOpeningTag( M_TOKEN( t ));
587 1868 : if( rtag.attribute( OOX_TOKEN( xml, space )) != "preserve" )
588 1200 : text += rtag.text.trim();
589 : else
590 668 : text += rtag.text;
591 1868 : stream.ensureClosingTag( M_TOKEN( t ));
592 1868 : break;
593 : }
594 : default:
595 0 : stream.handleUnexpectedTag();
596 0 : break;
597 : }
598 : }
599 1868 : stream.ensureClosingTag( M_TOKEN( r ));
600 1868 : return text.replaceAll("{", "\\{").replaceAll("}", "\\}");
601 : }
602 :
603 24 : OUString SmOoxmlImport::handleRad()
604 : {
605 24 : stream.ensureOpeningTag( M_TOKEN( rad ));
606 24 : bool degHide = false;
607 24 : if( stream.checkOpeningTag( M_TOKEN( radPr )))
608 : {
609 18 : if( XmlStream::Tag degHideTag = stream.checkOpeningTag( M_TOKEN( degHide )))
610 : {
611 16 : degHide = degHideTag.attribute( M_TOKEN( val ), degHide );
612 16 : stream.ensureClosingTag( M_TOKEN( degHide ));
613 18 : }
614 18 : stream.ensureClosingTag( M_TOKEN( radPr ));
615 : }
616 24 : OUString deg = readOMathArgInElement( M_TOKEN( deg ));
617 24 : OUString e = readOMathArgInElement( M_TOKEN( e ));
618 24 : stream.ensureClosingTag( M_TOKEN( rad ));
619 24 : if( degHide )
620 16 : return "sqrt {" + e + "}";
621 : else
622 8 : return "nroot {" + deg + "} {" + e + "}";
623 : }
624 :
625 16 : OUString SmOoxmlImport::handleSpre()
626 : {
627 16 : stream.ensureOpeningTag( M_TOKEN( sPre ));
628 16 : OUString sub = readOMathArgInElement( M_TOKEN( sub ));
629 16 : OUString sup = readOMathArgInElement( M_TOKEN( sup ));
630 16 : OUString e = readOMathArgInElement( M_TOKEN( e ));
631 16 : stream.ensureClosingTag( M_TOKEN( sPre ));
632 16 : return "{" + e + "} lsub {" + sub + "} lsup {" + sup + "}";
633 : }
634 :
635 32 : OUString SmOoxmlImport::handleSsub()
636 : {
637 32 : stream.ensureOpeningTag( M_TOKEN( sSub ));
638 32 : OUString e = readOMathArgInElement( M_TOKEN( e ));
639 32 : OUString sub = readOMathArgInElement( M_TOKEN( sub ));
640 32 : stream.ensureClosingTag( M_TOKEN( sSub ));
641 32 : return "{" + e + "} rsub {" + sub + "}";
642 : }
643 :
644 16 : OUString SmOoxmlImport::handleSsubsup()
645 : {
646 16 : stream.ensureOpeningTag( M_TOKEN( sSubSup ));
647 16 : OUString e = readOMathArgInElement( M_TOKEN( e ));
648 16 : OUString sub = readOMathArgInElement( M_TOKEN( sub ));
649 16 : OUString sup = readOMathArgInElement( M_TOKEN( sup ));
650 16 : stream.ensureClosingTag( M_TOKEN( sSubSup ));
651 16 : return "{" + e + "} rsub {" + sub + "} rsup {" + sup + "}";
652 : }
653 :
654 132 : OUString SmOoxmlImport::handleSsup()
655 : {
656 132 : stream.ensureOpeningTag( M_TOKEN( sSup ));
657 132 : OUString e = readOMathArgInElement( M_TOKEN( e ));
658 132 : OUString sup = readOMathArgInElement( M_TOKEN( sup ));
659 132 : stream.ensureClosingTag( M_TOKEN( sSup ));
660 132 : return "{" + e + "} ^ {" + sup + "}";
661 : }
662 :
663 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
