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 <osl/thread.h>
72 : #include <rtl/ustrbuf.hxx>
73 : #include <boost/scoped_array.hpp>
74 :
75 0 : LwpFormulaArg::~LwpFormulaArg()
76 : {
77 0 : }
78 :
79 0 : LwpFormulaInfo::LwpFormulaInfo(LwpObjectHeader &objHdr, LwpSvStream* pStrm)
80 : : LwpCellList(objHdr, pStrm)
81 : , m_bSupported(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 : 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 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 : 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 : OUString aText;
131 0 : aText += "\"";
132 0 : aText += OUString(pBuf.get(), nStrLen, osl_getThreadTextEncoding());
133 0 : aText += "\"";
134 :
135 0 : m_aStack.push_back(new LwpFormulaText(aText));
136 0 : return true;
137 : }
138 : /**
139 : *
140 : * @date 03/26/2005
141 : * @param
142 : * @param
143 : * @return sal_Bool.
144 : */
145 0 : bool LwpFormulaInfo::ReadCellID()
146 : {
147 0 : LwpRowSpecifier RowSpecifier;
148 0 : LwpColumnSpecifier ColumnSpecifier;
149 0 : 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 : bool LwpFormulaInfo::ReadCellRange()
166 : {
167 0 : bool readSucceeded = true;
168 0 : if (!ReadCellID( )) // start
169 0 : readSucceeded = false;
170 0 : LwpFormulaCellAddr* pStartCellAddr = static_cast<LwpFormulaCellAddr*>(m_aStack.back());
171 0 : m_aStack.pop_back();
172 :
173 0 : if (!ReadCellID()) // end
174 0 : readSucceeded = false;
175 0 : LwpFormulaCellAddr* pEndCellAddr = static_cast<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 : bool LwpFormulaInfo::ReadExpression()
196 : {
197 : sal_uInt16 TokenType, DiskLength;
198 0 : bool readSucceeded = 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 = 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 = 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 = 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 = 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 : 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 : bool readSucceeded = true;
314 :
315 0 : for (Count = 0; Count < NumberOfArguments; Count++)
316 : {
317 0 : ArgumentType = (sal_uInt8) m_pObjStrm->QuickReaduInt16(); // written as lushort
318 0 : ArgumentDiskLength = m_pObjStrm->QuickReaduInt16();
319 0 : bool bArgument = true;
320 :
321 0 : switch(ArgumentType)
322 : {
323 : case TK_CELLID:
324 0 : ReadCellID();
325 0 : break;
326 :
327 : case TK_CELLRANGE:
328 0 : ReadCellRange();
329 0 : break;
330 :
331 : case TK_CONSTANT:
332 0 : ReadConst();
333 0 : break;
334 :
335 : case TK_TEXT:
336 0 : ReadText();
337 0 : break;
338 :
339 : case TK_EXPRESSION:
340 0 : ReadExpression();
341 0 : break;
342 :
343 : default:
344 0 : bArgument = false;
345 0 : m_pObjStrm->SeekRel(ArgumentDiskLength);
346 0 : readSucceeded = false;
347 0 : break;
348 : }
349 :
350 0 : if (bArgument)
351 : {
352 0 : aFunc.AddArg( m_aStack.back() );
353 0 : m_aStack.pop_back();
354 : }
355 : }
356 0 : return readSucceeded;
357 : }
358 :
359 : /**
360 : *
361 : * @date 03/26/2005
362 : * @param
363 : * @param
364 : * @return
365 : */
366 0 : void LwpFormulaInfo::Read()
367 : {
368 0 : LwpCellList::Read();
369 : {
370 0 : LwpRowList* pRowList = static_cast<LwpRowList*>(cParent.obj().get());
371 0 : if (pRowList)
372 : {
373 0 : m_nFormulaRow = pRowList->GetRowID();
374 : }
375 : else
376 : {
377 : assert(false);
378 : }
379 : }
380 : // sal_uInt8 cFlags = (sal_uInt8) m_pObjStrm->QuickReaduInt16(); // written as a sal_uInt16
381 0 : m_pObjStrm->SeekRel(2);//flags, size in file: sal_uInt16
382 :
383 0 : LwpNotifyListPersistent cNotifyList;
384 0 : cNotifyList.Read(m_pObjStrm);
385 :
386 0 : ReadExpression();
387 :
388 0 : m_pObjStrm->SkipExtra();
389 0 : }
390 :
391 : /**
392 : * Make the formula string.
393 : * @date 03/26/2005
394 : * @param
395 : * @param
396 : * @return sal_Bool.
397 : */
398 0 : OUString LwpFormulaInfo::Convert(LwpTableLayout* pCellsMap)
399 : {
400 0 : OUString aFormula;
401 0 : if (m_bSupported)
402 : {
403 0 : if(1==m_aStack.size())
404 : {
405 0 : LwpFormulaArg* pFormula = m_aStack.back();
406 0 : aFormula = pFormula->ToString(pCellsMap);
407 : }
408 : else
409 : {
410 : assert(false);
411 : }
412 : }
413 0 : return aFormula;
414 : }
415 :
416 : /**
417 : * Fill the XFCell content
418 : * @date 03/26/2005
419 : * @param
420 : * @param
421 : * @return sal_Bool.
422 : */
423 0 : void LwpFormulaInfo::Convert(XFCell * pCell,LwpTableLayout* pCellsMap)
424 : {
425 0 : OUString aFormula;
426 0 : aFormula = Convert(pCellsMap);
427 0 : if (!aFormula.isEmpty())
428 : {
429 0 : pCell->SetFormula(aFormula);
430 : }
431 0 : LwpCellList::Convert(pCell);
432 0 : }
433 :
434 : /**
435 : *
436 : * @date 03/26/2005
437 : * @param
438 : * @param
439 : * @return sal_Bool.
440 : */
441 0 : LwpFormulaConst::LwpFormulaConst(double dVal)
442 : {
443 0 : m_dVal = dVal;
444 0 : }
445 :
446 0 : OUString LwpFormulaConst::ToString(LwpTableLayout* /*pCellsMap*/)
447 : {
448 0 : return OUString::number(m_dVal);
449 : }
450 :
451 : /**
452 : *
453 : * @date 03/26/2005
454 : * @param
455 : * @param
456 : * @return
457 : */
458 0 : LwpFormulaText::LwpFormulaText( const OUString& aText)
459 : {
460 0 : m_aText = aText;
461 0 : }
462 :
463 : /**
464 : *
465 : * @date 03/26/2005
466 : * @param
467 : * @param
468 : * @return
469 : */
470 0 : LwpFormulaCellAddr::LwpFormulaCellAddr(sal_Int16 aCol, sal_Int16 aRow)
471 : {
472 0 : m_aCol = aCol;
473 0 : m_aRow = aRow;
474 0 : }
475 :
476 : /**
477 : *
478 : * @date 03/26/2005
479 : * @param
480 : * @param
481 : * @return String
482 : */
483 0 : OUString LwpFormulaCellAddr::ToString(LwpTableLayout* pCellsMap)
484 : {
485 0 : OUString aCellAddr = "<" + LwpFormulaTools::GetCellAddr(m_aRow,m_aCol,pCellsMap) + ">";
486 0 : return aCellAddr;
487 : }
488 :
489 : /**
490 : *
491 : * @date 03/26/2005
492 : * @param
493 : * @param
494 : * @return
495 : */
496 0 : LwpFormulaCellRangeAddr::LwpFormulaCellRangeAddr(sal_Int16 aStartCol,
497 : sal_Int16 aStartRow,
498 : sal_Int16 aEndCol,
499 0 : sal_Int16 aEndRow)
500 : {
501 0 : m_aStartCol = aStartCol;
502 0 : m_aStartRow = aStartRow;
503 0 : m_aEndCol = aEndCol;
504 0 : m_aEndRow = aEndRow;
505 0 : }
506 :
507 : /**
508 : * Convert the cell range into a string
509 : * @date 03/26/2005
510 : * @param
511 : * @param
512 : * @return String.
513 : */
514 0 : OUString LwpFormulaCellRangeAddr::ToString(LwpTableLayout* pCellsMap)
515 : {
516 : OUString aCellAddr = "<"
517 0 : + LwpFormulaTools::GetCellAddr(m_aStartRow,m_aStartCol,pCellsMap) + ":"
518 0 : + LwpFormulaTools::GetCellAddr(m_aEndRow,m_aEndCol,pCellsMap) + ">";
519 :
520 0 : return aCellAddr;
521 : }
522 :
523 : /**
524 : *
525 : * @date 03/26/2005
526 : * @param
527 : * @param
528 : * @return
529 : */
530 0 : LwpFormulaFunc::LwpFormulaFunc(sal_uInt16 nTokenType)
531 : {
532 0 : m_nTokenType = nTokenType;
533 0 : }
534 :
535 : /**
536 : *
537 : * @date 03/26/2005
538 : * @param
539 : * @param
540 : * @return
541 : */
542 0 : LwpFormulaFunc::~LwpFormulaFunc()
543 : {
544 : try
545 : {
546 0 : while(m_aArgs.size()>0)
547 : {
548 0 : LwpFormulaArg* pArg = m_aArgs.back();
549 0 : m_aArgs.pop_back();
550 0 : delete pArg;pArg=NULL;
551 : }
552 0 : }catch (...) {
553 : assert(false);
554 : }
555 :
556 0 : }
557 : /**
558 : *
559 : * @date 03/26/2005
560 : * @param
561 : * @param
562 : * @return
563 : */
564 0 : void LwpFormulaFunc::AddArg(LwpFormulaArg* pArg)
565 : {
566 0 : m_aArgs.push_back(pArg);
567 0 : }
568 : /**
569 : * Convert the functions to a string, which is a argument of other formula
570 : * @date 03/26/2005
571 : * @param
572 : * @param
573 : * @return String.
574 : */
575 0 : OUString LwpFormulaFunc::ToArgString(LwpTableLayout* pCellsMap)
576 : {
577 0 : OUStringBuffer aFormula;
578 0 : aFormula.append('(');
579 0 : aFormula.append(ToString(pCellsMap));
580 0 : aFormula.append(')');
581 0 : return aFormula.makeStringAndClear();
582 : }
583 : /**
584 : * Convert the function to a formula string.
585 : * @date 03/26/2005
586 : * @param
587 : * @param
588 : * @return sal_Bool.
589 : */
590 0 : OUString LwpFormulaFunc::ToString(LwpTableLayout* pCellsMap)
591 : {
592 0 : OUString aFormula;
593 :
594 0 : OUString aFuncName = LwpFormulaTools::GetName(m_nTokenType);
595 0 : aFormula += aFuncName;
596 0 : aFormula += " ";//Append a blank space
597 :
598 : //Append args
599 0 : std::vector<LwpFormulaArg*>::iterator aItr;
600 0 : for (aItr=m_aArgs.begin();aItr!=m_aArgs.end();++aItr)
601 : {
602 0 : aFormula += (*aItr)->ToArgString(pCellsMap) + "|"; //separator
603 : }
604 :
605 : //erase the last "|"
606 0 : if (!m_aArgs.empty())
607 : {
608 0 : aFormula = aFormula.replaceAt(aFormula.getLength()-1,1,"");
609 : }
610 : else
611 : {
612 : assert(false);
613 : }
614 :
615 0 : return aFormula;
616 : }
617 :
618 : /**
619 : * Convert the formula in operators to a string : e.g. 1+2+3
620 : * @date 03/26/2005
621 : * @param
622 : * @param
623 : * @return sal_Bool.
624 : */
625 0 : OUString LwpFormulaOp::ToString(LwpTableLayout* pCellsMap)
626 : {
627 0 : OUString aFormula;
628 0 : if (2==m_aArgs.size())
629 : {
630 0 : std::vector<LwpFormulaArg*>::iterator aItr = m_aArgs.end();
631 0 : --aItr;
632 :
633 0 : aFormula += (*aItr)->ToArgString(pCellsMap) + " ";
634 0 : OUString aFuncName = LwpFormulaTools::GetName(m_nTokenType);
635 :
636 0 : aFormula += aFuncName + " ";
637 :
638 0 : --aItr;
639 0 : aFormula += (*aItr)->ToArgString(pCellsMap);
640 : }
641 : else
642 : {
643 : assert(false);
644 : }
645 0 : return aFormula;
646 : }
647 :
648 : /**
649 : * convert the formula in unary operators into string : e.g. -2
650 : * @date 03/26/2005
651 : * @param
652 : * @param
653 : * @return sal_Bool.
654 : */
655 0 : OUString LwpFormulaUnaryOp::ToString(LwpTableLayout* pCellsMap)
656 : {
657 0 : OUString aFormula;
658 0 : if (1==m_aArgs.size())
659 : {
660 0 : OUString aFuncName = LwpFormulaTools::GetName(m_nTokenType);
661 0 : aFormula += aFuncName;
662 :
663 0 : std::vector<LwpFormulaArg*>::iterator aItr = m_aArgs.begin();
664 0 : aFormula += (*aItr)->ToArgString(pCellsMap);
665 : }
666 : else
667 : {
668 : assert(false);
669 : }
670 0 : return aFormula;
671 : }
672 : /**
673 : * Get token name
674 : * @date 03/26/2005
675 : * @param
676 : * @param
677 : * @return String.
678 : */
679 0 : OUString LwpFormulaTools::GetName(sal_uInt16 nTokenType)
680 : {
681 0 : OUString aName;
682 0 : switch(nTokenType)
683 : {
684 : case TK_SUM:
685 0 : aName = "SUM";
686 0 : break;
687 : case TK_IF:
688 0 : aName = "IF";//Not supported by SODC
689 0 : break;
690 : case TK_COUNT:
691 0 : aName = "COUNT";//Not supported by SODC
692 0 : break;
693 : case TK_MINIMUM:
694 0 : aName = "MIN";
695 0 : break;
696 : case TK_MAXIMUM:
697 0 : aName = "MAX";
698 0 : break;
699 : case TK_AVERAGE:
700 0 : aName = "MEAN";
701 0 : break;
702 : case TK_ADD:
703 0 : aName = "+";
704 0 : break;
705 : case TK_SUBTRACT:
706 0 : aName = "-";
707 0 : break;
708 : case TK_MULTIPLY:
709 0 : aName = "*";
710 0 : break;
711 : case TK_DIVIDE:
712 0 : aName = "/";
713 0 : break;
714 : case TK_UNARY_MINUS:
715 0 : aName = "-";
716 0 : break;
717 : case TK_LESS:
718 0 : aName = "L";
719 0 : break;
720 : case TK_LESS_OR_EQUAL:
721 0 : aName = "LEQ";
722 0 : break;
723 : case TK_GREATER:
724 0 : aName = "G";
725 0 : break;
726 : case TK_GREATER_OR_EQUAL:
727 0 : aName = "GEQ";
728 0 : break;
729 : case TK_EQUAL:
730 0 : aName = "EQ";
731 0 : break;
732 : case TK_NOT_EQUAL:
733 0 : aName = "NEQ";
734 0 : break;
735 : case TK_NOT:
736 0 : aName = "NOT";
737 0 : break;
738 : case TK_AND:
739 0 : aName = "AND";
740 0 : break;
741 : case TK_OR:
742 0 : aName = "OR";
743 0 : break;
744 : default:
745 : assert(false);
746 0 : break;
747 : }
748 0 : return aName;
749 : }
750 :
751 : /**
752 : * Get cell address in String
753 : * @date 03/26/2005
754 : * @param
755 : * @param
756 : * @return String.
757 : */
758 0 : OUString LwpFormulaTools::GetCellAddr(sal_Int16 nRow, sal_Int16 nCol, LwpTableLayout* pCellsMap)
759 : {
760 0 : OUString aCellAddr;
761 0 : XFCell* pCell = pCellsMap->GetCellsMap(nRow,(sal_uInt8)nCol);
762 0 : if (pCell)
763 : {
764 0 : aCellAddr = pCell->GetCellName();
765 : }
766 : else
767 : {
768 : assert( -1==nRow || -1==(sal_Int8)nCol);
769 : }
770 0 : return aCellAddr;
771 : }
772 :
773 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
