Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*************************************************************************
3 : *
4 : * The Contents of this file are made available subject to the terms of
5 : * either of the following licenses
6 : *
7 : * - GNU Lesser General Public License Version 2.1
8 : * - Sun Industry Standards Source License Version 1.1
9 : *
10 : * Sun Microsystems Inc., October, 2000
11 : *
12 : * GNU Lesser General Public License Version 2.1
13 : * =============================================
14 : * Copyright 2000 by Sun Microsystems, Inc.
15 : * 901 San Antonio Road, Palo Alto, CA 94303, USA
16 : *
17 : * This library is free software; you can redistribute it and/or
18 : * modify it under the terms of the GNU Lesser General Public
19 : * License version 2.1, as published by the Free Software Foundation.
20 : *
21 : * This library is distributed in the hope that it will be useful,
22 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 : * Lesser General Public License for more details.
25 : *
26 : * You should have received a copy of the GNU Lesser General Public
27 : * License along with this library; if not, write to the Free Software
28 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
29 : * MA 02111-1307 USA
30 : *
31 : *
32 : * Sun Industry Standards Source License Version 1.1
33 : * =================================================
34 : * The contents of this file are subject to the Sun Industry Standards
35 : * Source License Version 1.1 (the "License"); You may not use this file
36 : * except in compliance with the License. You may obtain a copy of the
37 : * License at http://www.openoffice.org/license.html.
38 : *
39 : * Software provided under this License is provided on an "AS IS" basis,
40 : * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
41 : * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
42 : * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
43 : * See the License for the specific provisions governing your rights and
44 : * obligations concerning the Software.
45 : *
46 : * The Initial Developer of the Original Code is: IBM Corporation
47 : *
48 : * Copyright: 2008 by IBM Corporation
49 : *
50 : * All Rights Reserved.
51 : *
52 : * Contributor(s): _______________________________________
53 : *
54 : *
55 : ************************************************************************/
56 : /**
57 : * @file
58 : * For LWP filter architecture prototype - table cell numerics format
59 : */
60 : /*************************************************************************
61 : * Change History
62 : Mar 2005 Created
63 : ************************************************************************/
64 :
65 : #include "lwpoverride.hxx"
66 : #include "lwptblcell.hxx"
67 : #include "lwppara.hxx"
68 : #include "lwptblformula.hxx"
69 :
70 : #include "lwptablelayout.hxx"
71 : #include <rtl/ustrbuf.hxx>
72 : #include <boost/scoped_array.hpp>
73 :
74 0 : LwpFormulaArg::~LwpFormulaArg()
75 : {
76 0 : }
77 :
78 : //////////////////////////////////////////////////////////////////
79 0 : LwpFormulaInfo::LwpFormulaInfo(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
80 : : LwpCellList(objHdr, pStrm)
81 : , m_bSupported(sal_True)
82 0 : , m_nFormulaRow(0)
83 0 : {}
84 :
85 0 : LwpFormulaInfo::~LwpFormulaInfo()
86 : {
87 : try{
88 0 : while(m_aStack.size()>0)
89 : {
90 0 : LwpFormulaArg* pArg=m_aStack.back();
91 0 : m_aStack.pop_back();
92 0 : delete pArg; pArg=NULL;
93 : }
94 0 : }catch (...)
95 : {
96 : assert(false);
97 : }
98 0 : }
99 :
100 : /**
101 : *
102 : * @date 03/26/2005
103 : * @param
104 : * @param
105 : * @return sal_Bool.
106 : */
107 0 : sal_Bool LwpFormulaInfo::ReadConst()
108 : {
109 0 : double Constant = m_pObjStrm->QuickReadDouble();
110 :
111 0 : m_aStack.push_back( new LwpFormulaConst(Constant) );
112 :
113 0 : return sal_True;
114 : }
115 : /**
116 : * Need more effort for unicode.
117 : * @date 03/26/2005
118 : * @param
119 : * @param
120 : * @return sal_Bool.
121 : */
122 0 : sal_Bool LwpFormulaInfo::ReadText()
123 : {
124 0 : m_pObjStrm->QuickReadInt16(); //Disk Size
125 0 : sal_uInt16 nStrLen = m_pObjStrm->QuickReadInt16();
126 :
127 0 : boost::scoped_array<char> pBuf(new char[nStrLen+1]);
128 0 : m_pObjStrm->QuickRead( pBuf.get(), nStrLen );
129 0 : *(pBuf.get()+nStrLen)='\0';
130 0 : String aText;
131 0 : aText += rtl::OUString("\"");
132 0 : aText.Append(String(pBuf.get(),nStrLen,osl_getThreadTextEncoding()));
133 0 : aText += rtl::OUString("\"");
134 :
135 0 : m_aStack.push_back(new LwpFormulaText(aText));
136 0 : return sal_True;
137 : }
138 : /**
139 : *
140 : * @date 03/26/2005
141 : * @param
142 : * @param
143 : * @return sal_Bool.
144 : */
145 0 : sal_Bool LwpFormulaInfo::ReadCellID()
146 : {
147 0 : LwpRowSpecifier RowSpecifier;
148 0 : LwpColumnSpecifier ColumnSpecifier;
149 0 : sal_Bool readSucceeded = true;
150 :
151 0 : RowSpecifier.QuickRead(m_pObjStrm);
152 0 : ColumnSpecifier.QuickRead(m_pObjStrm);
153 :
154 0 : m_aStack.push_back( new LwpFormulaCellAddr(ColumnSpecifier.ColumnID(cColumn),
155 0 : RowSpecifier.RowID(m_nFormulaRow)) );
156 0 : return readSucceeded;
157 : }
158 : /**
159 : *
160 : * @date 03/26/2005
161 : * @param
162 : * @param
163 : * @return sal_Bool.
164 : */
165 0 : sal_Bool LwpFormulaInfo::ReadCellRange()
166 : {
167 0 : sal_Bool readSucceeded = sal_True;
168 0 : if (!ReadCellID( )) // start
169 0 : readSucceeded = false;
170 0 : LwpFormulaCellAddr* pStartCellAddr = (LwpFormulaCellAddr*)m_aStack.back();
171 0 : m_aStack.pop_back();
172 :
173 0 : if (!ReadCellID()) // end
174 0 : readSucceeded = false;
175 0 : LwpFormulaCellAddr* pEndCellAddr = (LwpFormulaCellAddr*)m_aStack.back();
176 0 : m_aStack.pop_back();
177 :
178 0 : m_aStack.push_back( new LwpFormulaCellRangeAddr(pStartCellAddr->GetCol(),
179 0 : pStartCellAddr->GetRow(),
180 0 : pEndCellAddr->GetCol(),
181 0 : pEndCellAddr->GetRow()) );
182 0 : delete pStartCellAddr;
183 0 : delete pEndCellAddr;
184 :
185 0 : return readSucceeded;
186 : }
187 :
188 : /**
189 : * Read expression from wordpro file
190 : * @date 03/26/2005
191 : * @param
192 : * @param
193 : * @return sal_Bool.
194 : */
195 0 : sal_Bool LwpFormulaInfo::ReadExpression()
196 : {
197 : sal_uInt16 TokenType, DiskLength;
198 0 : sal_Bool readSucceeded = sal_True;
199 :
200 : /* Read the compiled expression length */
201 : // Len = m_pObjStrm->QuickReaduInt16();
202 0 : m_pObjStrm->SeekRel(2);
203 :
204 0 : while ((TokenType = m_pObjStrm->QuickReaduInt16()) != TK_END)
205 : {
206 : // Get the disk length of this token
207 0 : DiskLength = m_pObjStrm->QuickReaduInt16();
208 :
209 0 : switch (TokenType)
210 : {
211 : case TK_CONSTANT:
212 : {
213 0 : ReadConst();
214 0 : break;
215 : }
216 :
217 : case TK_CELLID:
218 0 : if (!ReadCellID())
219 0 : readSucceeded = sal_False;
220 0 : break;
221 :
222 : case TK_CELLRANGE:
223 0 : readSucceeded = ReadCellRange();
224 0 : break;
225 :
226 : case TK_SUM:
227 : case TK_IF:
228 : case TK_COUNT:
229 : case TK_MINIMUM:
230 : case TK_MAXIMUM:
231 : case TK_AVERAGE:
232 : {
233 0 : LwpFormulaFunc* pFunc = new LwpFormulaFunc(TokenType);
234 0 : if (!ReadArguments(*pFunc))
235 0 : readSucceeded = sal_False;
236 0 : m_aStack.push_back(pFunc);
237 : }
238 0 : break;
239 :
240 : case TK_ADD://7
241 : case TK_SUBTRACT:
242 : case TK_MULTIPLY:
243 : case TK_DIVIDE:
244 : case TK_LESS:
245 : case TK_LESS_OR_EQUAL:
246 : case TK_GREATER:
247 : case TK_GREATER_OR_EQUAL:
248 : case TK_EQUAL:
249 : case TK_NOT_EQUAL:
250 : case TK_AND:
251 : case TK_OR:
252 : case TK_NOT:
253 0 : m_pObjStrm->SeekRel(DiskLength); // extensible for future
254 :
255 : {//binary operator
256 0 : LwpFormulaOp* pOp = new LwpFormulaOp(TokenType);
257 0 : pOp->AddArg(m_aStack.back()); m_aStack.pop_back();
258 0 : pOp->AddArg(m_aStack.back()); m_aStack.pop_back();
259 0 : m_aStack.push_back(pOp);
260 : }
261 0 : break;
262 : case TK_UNARY_MINUS:
263 : {
264 0 : LwpFormulaUnaryOp* pOp = new LwpFormulaUnaryOp(TokenType);
265 0 : pOp->AddArg(m_aStack.back()); m_aStack.pop_back();
266 0 : m_aStack.push_back(pOp);
267 : }
268 0 : break;
269 : default:
270 : // We don't know what to do with this token, so eat it.
271 0 : m_pObjStrm->SeekRel(DiskLength);
272 0 : readSucceeded = sal_False;
273 0 : break;
274 : }
275 0 : MarkUnsupported(TokenType);
276 : }
277 0 : return readSucceeded;
278 : }
279 :
280 : /**
281 : *
282 : * @date 03/26/2005
283 : * @param
284 : * @param
285 : * @return
286 : */
287 0 : void LwpFormulaInfo::MarkUnsupported(sal_uInt16 TokenType)
288 : {
289 0 : switch(TokenType)
290 : {
291 : case TK_IF:
292 : case TK_COUNT:
293 : case TK_NOT:
294 : {
295 0 : m_bSupported = sal_False;//Not supported formulas
296 : }
297 0 : break;
298 : default:
299 0 : break;
300 : }
301 0 : }
302 : /**
303 : * Read arguments of functions from wordpro file
304 : * @date 03/26/2005
305 : * @param LwpFormulaFunc& aFunc, functions object
306 : * @return sal_Bool.
307 : */
308 0 : sal_Bool LwpFormulaInfo::ReadArguments(LwpFormulaFunc& aFunc)
309 : {
310 0 : sal_uInt16 NumberOfArguments = m_pObjStrm->QuickReaduInt16();
311 : sal_uInt16 ArgumentDiskLength, Count;
312 : sal_uInt8 ArgumentType;
313 0 : sal_Bool bArgument = sal_False;
314 0 : sal_Bool readSucceeded = sal_True;
315 :
316 0 : for (Count = 0; Count < NumberOfArguments; Count++)
317 : {
318 0 : ArgumentType = (sal_uInt8) m_pObjStrm->QuickReaduInt16(); // written as lushort
319 0 : ArgumentDiskLength = m_pObjStrm->QuickReaduInt16();
320 0 : bArgument = sal_True;
321 :
322 0 : switch(ArgumentType)
323 : {
324 : case TK_CELLID:
325 0 : ReadCellID();
326 0 : break;
327 :
328 : case TK_CELLRANGE:
329 0 : ReadCellRange();
330 0 : break;
331 :
332 : case TK_CONSTANT:
333 0 : ReadConst();
334 0 : break;
335 :
336 : case TK_TEXT:
337 0 : ReadText();
338 0 : break;
339 :
340 : case TK_EXPRESSION:
341 0 : ReadExpression();
342 0 : break;
343 :
344 : default:
345 0 : bArgument = sal_False;
346 0 : m_pObjStrm->SeekRel(ArgumentDiskLength);
347 0 : readSucceeded = sal_False;
348 0 : break;
349 : }
350 :
351 0 : if (bArgument)
352 : {
353 0 : aFunc.AddArg( m_aStack.back() );
354 0 : m_aStack.pop_back();
355 : }
356 : }
357 0 : return readSucceeded;
358 : }
359 :
360 : /**
361 : *
362 : * @date 03/26/2005
363 : * @param
364 : * @param
365 : * @return
366 : */
367 0 : void LwpFormulaInfo::Read()
368 : {
369 0 : LwpCellList::Read();
370 : {
371 0 : LwpRowList* pRowList =(LwpRowList*)cParent.obj();
372 0 : if (pRowList)
373 : {
374 0 : m_nFormulaRow = pRowList->GetRowID();
375 : }
376 : else
377 : {
378 : assert(false);
379 : }
380 : }
381 : // sal_uInt8 cFlags = (sal_uInt8) m_pObjStrm->QuickReaduInt16(); // written as a sal_uInt16
382 0 : m_pObjStrm->SeekRel(2);//flags, size in file: sal_uInt16
383 :
384 0 : LwpNotifyListPersistent cNotifyList;
385 0 : cNotifyList.Read(m_pObjStrm);
386 :
387 0 : ReadExpression();
388 :
389 0 : m_pObjStrm->SkipExtra();
390 0 : }
391 :
392 : /**
393 : * Make the formula string.
394 : * @date 03/26/2005
395 : * @param
396 : * @param
397 : * @return sal_Bool.
398 : */
399 0 : String LwpFormulaInfo::Convert(LwpTableLayout* pCellsMap)
400 : {
401 0 : String aFormula;
402 0 : if (m_bSupported)
403 : {
404 0 : if(1==m_aStack.size())
405 : {
406 0 : LwpFormulaArg* pFormula = m_aStack.back();
407 0 : aFormula = pFormula->ToString(pCellsMap);
408 : }
409 : else
410 : {
411 : assert(false);
412 : }
413 : }
414 0 : return aFormula;
415 : }
416 :
417 : /**
418 : * Fill the XFCell content
419 : * @date 03/26/2005
420 : * @param
421 : * @param
422 : * @return sal_Bool.
423 : */
424 0 : void LwpFormulaInfo::Convert(XFCell * pCell,LwpTableLayout* pCellsMap)
425 : {
426 0 : String aFormula;
427 0 : aFormula = Convert(pCellsMap);
428 0 : if (aFormula.Len())
429 : {
430 0 : pCell->SetFormula(aFormula);
431 : }
432 0 : LwpCellList::Convert(pCell);
433 0 : }
434 :
435 : //////////////////////////////////////////////////////////////////
436 :
437 : /**
438 : *
439 : * @date 03/26/2005
440 : * @param
441 : * @param
442 : * @return sal_Bool.
443 : */
444 0 : LwpFormulaConst::LwpFormulaConst(double dVal)
445 : {
446 0 : m_dVal = dVal;
447 0 : }
448 :
449 0 : rtl::OUString LwpFormulaConst::ToString(LwpTableLayout* /*pCellsMap*/)
450 : {
451 0 : return rtl::OUString::valueOf(m_dVal);
452 : }
453 :
454 : /**
455 : *
456 : * @date 03/26/2005
457 : * @param
458 : * @param
459 : * @return
460 : */
461 0 : LwpFormulaText::LwpFormulaText( String aText)
462 : {
463 0 : m_aText = aText;
464 0 : }
465 :
466 : /**
467 : *
468 : * @date 03/26/2005
469 : * @param
470 : * @param
471 : * @return
472 : */
473 0 : LwpFormulaCellAddr::LwpFormulaCellAddr(sal_Int16 aCol, sal_Int16 aRow)
474 : {
475 0 : m_aCol = aCol;
476 0 : m_aRow = aRow;
477 0 : }
478 :
479 : /**
480 : *
481 : * @date 03/26/2005
482 : * @param
483 : * @param
484 : * @return String
485 : */
486 0 : rtl::OUString LwpFormulaCellAddr::ToString(LwpTableLayout* pCellsMap)
487 : {
488 0 : String aCellAddr;
489 0 : aCellAddr.AppendAscii("<");//<
490 :
491 0 : aCellAddr += LwpFormulaTools::GetCellAddr(m_aRow,m_aCol,pCellsMap);
492 :
493 0 : aCellAddr.AppendAscii(">");//>
494 0 : return aCellAddr;
495 : }
496 :
497 : /**
498 : *
499 : * @date 03/26/2005
500 : * @param
501 : * @param
502 : * @return
503 : */
504 0 : LwpFormulaCellRangeAddr::LwpFormulaCellRangeAddr(sal_Int16 aStartCol,
505 : sal_Int16 aStartRow,
506 : sal_Int16 aEndCol,
507 0 : sal_Int16 aEndRow)
508 : {
509 0 : m_aStartCol = aStartCol;
510 0 : m_aStartRow = aStartRow;
511 0 : m_aEndCol = aEndCol;
512 0 : m_aEndRow = aEndRow;
513 0 : }
514 :
515 : /**
516 : * Convert the cell range into a string
517 : * @date 03/26/2005
518 : * @param
519 : * @param
520 : * @return String.
521 : */
522 0 : rtl::OUString LwpFormulaCellRangeAddr::ToString(LwpTableLayout* pCellsMap)
523 : {
524 0 : String aCellAddr;
525 0 : aCellAddr.AppendAscii("<");//<
526 :
527 0 : aCellAddr += LwpFormulaTools::GetCellAddr(m_aStartRow,m_aStartCol,pCellsMap);
528 0 : aCellAddr.AppendAscii(":");
529 0 : aCellAddr += LwpFormulaTools::GetCellAddr(m_aEndRow,m_aEndCol,pCellsMap);
530 :
531 0 : aCellAddr.AppendAscii(">");//>
532 :
533 0 : return aCellAddr;
534 : }
535 :
536 : /**
537 : *
538 : * @date 03/26/2005
539 : * @param
540 : * @param
541 : * @return
542 : */
543 0 : LwpFormulaFunc::LwpFormulaFunc(sal_uInt16 nTokenType)
544 : {
545 0 : m_nTokenType = nTokenType;
546 0 : }
547 :
548 : /**
549 : *
550 : * @date 03/26/2005
551 : * @param
552 : * @param
553 : * @return
554 : */
555 0 : LwpFormulaFunc::~LwpFormulaFunc()
556 : {
557 : try
558 : {
559 0 : while(m_aArgs.size()>0)
560 : {
561 0 : LwpFormulaArg* pArg = m_aArgs.back();
562 0 : m_aArgs.pop_back();
563 0 : delete pArg;pArg=NULL;
564 : }
565 0 : }catch (...) {
566 : assert(false);
567 : }
568 :
569 0 : }
570 : /**
571 : *
572 : * @date 03/26/2005
573 : * @param
574 : * @param
575 : * @return
576 : */
577 0 : void LwpFormulaFunc::AddArg(LwpFormulaArg* pArg)
578 : {
579 0 : m_aArgs.push_back(pArg);
580 0 : }
581 : /**
582 : * Convert the functions to a string, which is a argument of other formula
583 : * @date 03/26/2005
584 : * @param
585 : * @param
586 : * @return String.
587 : */
588 0 : String LwpFormulaFunc::ToArgString(LwpTableLayout* pCellsMap)
589 : {
590 0 : rtl::OUStringBuffer aFormula;
591 0 : aFormula.append(static_cast<sal_Unicode>('('));
592 0 : aFormula.append(ToString(pCellsMap));
593 0 : aFormula.append(static_cast<sal_Unicode>(')'));
594 0 : return aFormula.makeStringAndClear();
595 : }
596 : /**
597 : * Convert the function to a formula string.
598 : * @date 03/26/2005
599 : * @param
600 : * @param
601 : * @return sal_Bool.
602 : */
603 0 : rtl::OUString LwpFormulaFunc::ToString(LwpTableLayout* pCellsMap)
604 : {
605 0 : String aFormula;
606 :
607 0 : String aFuncName = LwpFormulaTools::GetName(m_nTokenType);
608 0 : aFormula += aFuncName;
609 0 : aFormula.AppendAscii(" ");//Append a blank space
610 :
611 : //Append args
612 0 : vector<LwpFormulaArg*>::iterator aItr;
613 0 : for (aItr=m_aArgs.begin();aItr!=m_aArgs.end();++aItr)
614 : {
615 0 : aFormula.Append( (*aItr)->ToArgString(pCellsMap) );
616 0 : aFormula.AppendAscii("|");//separator
617 : }
618 :
619 : //erase the last "|"
620 0 : if (!m_aArgs.empty())
621 : {
622 0 : aFormula.Erase(aFormula.Len()-1,1);
623 : }
624 : else
625 : {
626 : assert(false);
627 : }
628 :
629 0 : return aFormula;
630 : }
631 :
632 : /**
633 : * Convert the formula in operators to a string : e.g. 1+2+3
634 : * @date 03/26/2005
635 : * @param
636 : * @param
637 : * @return sal_Bool.
638 : */
639 0 : rtl::OUString LwpFormulaOp::ToString(LwpTableLayout* pCellsMap)
640 : {
641 0 : String aFormula;
642 0 : if (2==m_aArgs.size())
643 : {
644 0 : vector<LwpFormulaArg*>::iterator aItr = m_aArgs.end();
645 0 : --aItr;
646 0 : aFormula.Append( (*aItr)->ToArgString(pCellsMap) );
647 :
648 0 : aFormula.AppendAscii(" ");
649 :
650 0 : String aFuncName = LwpFormulaTools::GetName(m_nTokenType);
651 0 : aFormula.Append(aFuncName);
652 :
653 0 : aFormula.AppendAscii(" ");
654 :
655 0 : --aItr;
656 0 : aFormula.Append( (*aItr)->ToArgString(pCellsMap) );
657 : }
658 : else
659 : {
660 : assert(false);
661 : }
662 0 : return aFormula;
663 : }
664 :
665 : /**
666 : * convert the formula in unary operators into string : e.g. -2
667 : * @date 03/26/2005
668 : * @param
669 : * @param
670 : * @return sal_Bool.
671 : */
672 0 : rtl::OUString LwpFormulaUnaryOp::ToString(LwpTableLayout* pCellsMap)
673 : {
674 0 : String aFormula;
675 0 : if (1==m_aArgs.size())
676 : {
677 0 : String aFuncName = LwpFormulaTools::GetName(m_nTokenType);
678 0 : aFormula.Append(aFuncName);
679 :
680 0 : vector<LwpFormulaArg*>::iterator aItr = m_aArgs.begin();
681 0 : aFormula.Append( (*aItr)->ToArgString(pCellsMap) );
682 : }
683 : else
684 : {
685 : assert(false);
686 : }
687 0 : return aFormula;
688 : }
689 : /**
690 : * Get token name
691 : * @date 03/26/2005
692 : * @param
693 : * @param
694 : * @return String.
695 : */
696 0 : String LwpFormulaTools::GetName(sal_uInt16 nTokenType)
697 : {
698 0 : String aName;
699 0 : switch(nTokenType)
700 : {
701 : case TK_SUM:
702 0 : aName = rtl::OUString("SUM");
703 0 : break;
704 : case TK_IF:
705 0 : aName = rtl::OUString("IF");//Not supported by SODC
706 0 : break;
707 : case TK_COUNT:
708 0 : aName = rtl::OUString("COUNT");//Not supported by SODC
709 0 : break;
710 : case TK_MINIMUM:
711 0 : aName = rtl::OUString("MIN");
712 0 : break;
713 : case TK_MAXIMUM:
714 0 : aName = rtl::OUString("MAX");
715 0 : break;
716 : case TK_AVERAGE:
717 0 : aName = rtl::OUString("MEAN");
718 0 : break;
719 : case TK_ADD:
720 0 : aName = rtl::OUString("+");
721 0 : break;
722 : case TK_SUBTRACT:
723 0 : aName = rtl::OUString("-");
724 0 : break;
725 : case TK_MULTIPLY:
726 0 : aName = rtl::OUString("*");
727 0 : break;
728 : case TK_DIVIDE:
729 0 : aName = rtl::OUString("/");
730 0 : break;
731 : case TK_UNARY_MINUS:
732 0 : aName = rtl::OUString("-");
733 0 : break;
734 : case TK_LESS:
735 0 : aName = rtl::OUString("L");
736 0 : break;
737 : case TK_LESS_OR_EQUAL:
738 0 : aName = rtl::OUString("LEQ");
739 0 : break;
740 : case TK_GREATER:
741 0 : aName = rtl::OUString("G");
742 0 : break;
743 : case TK_GREATER_OR_EQUAL:
744 0 : aName = rtl::OUString("GEQ");
745 0 : break;
746 : case TK_EQUAL:
747 0 : aName = rtl::OUString("EQ");
748 0 : break;
749 : case TK_NOT_EQUAL:
750 0 : aName = rtl::OUString("NEQ");
751 0 : break;
752 : case TK_NOT:
753 0 : aName = rtl::OUString("NOT");
754 0 : break;
755 : case TK_AND:
756 0 : aName = rtl::OUString("AND");
757 0 : break;
758 : case TK_OR:
759 0 : aName = rtl::OUString("OR");
760 0 : break;
761 : default:
762 : assert(false);
763 0 : break;
764 : }
765 0 : return aName;
766 : }
767 :
768 : /**
769 : * Get cell address in String
770 : * @date 03/26/2005
771 : * @param
772 : * @param
773 : * @return String.
774 : */
775 0 : String LwpFormulaTools::GetCellAddr(sal_Int16 nRow, sal_Int16 nCol, LwpTableLayout* pCellsMap)
776 : {
777 0 : String aCellAddr;
778 0 : XFCell* pCell = pCellsMap->GetCellsMap(nRow,(sal_uInt8)nCol);
779 0 : if (pCell)
780 : {
781 0 : aCellAddr = pCell->GetCellName();
782 : }
783 : else
784 : {
785 : assert( -1==nRow || -1==(sal_Int8)nCol);
786 : }
787 0 : return aCellAddr;
788 : }
789 :
790 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
