?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 4.0.2.1, tag libreoffice-4.0.2.1
[LibreOffice.git] / sc / source / filter / excel / xihelper.cxx
blobad5d1f8c1f124c12294222254393b15f758ade6f
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include "xihelper.hxx"
21 #include <svl/itemset.hxx>
22 #include <editeng/editobj.hxx>
23 #include <tools/urlobj.hxx>
24 #include "scitems.hxx"
25 #include <editeng/eeitem.hxx>
26 #include <editeng/flditem.hxx>
27 #include "document.hxx"
28 #include "cell.hxx"
29 #include "rangelst.hxx"
30 #include "editutil.hxx"
31 #include "attrib.hxx"
32 #include "xltracer.hxx"
33 #include "xistream.hxx"
34 #include "xistyle.hxx"
35
36 #include "excform.hxx"
37
38 // Excel->Calc cell address/range conversion ==================================
39
40 namespace {
41
42 /** Fills the passed Calc address with the passed Excel cell coordinates without checking any limits. */
43 inline void lclFillAddress( ScAddress& rScPos, sal_uInt16 nXclCol, sal_uInt32 nXclRow, SCTAB nScTab )
44 {
45 rScPos.SetCol( static_cast< SCCOL >( nXclCol ) );
46 rScPos.SetRow( static_cast< SCROW >( nXclRow ) );
47 rScPos.SetTab( nScTab );
48 }
49
50 } // namespace
51
52 // ----------------------------------------------------------------------------
53
54 XclImpAddressConverter::XclImpAddressConverter( const XclImpRoot& rRoot ) :
55 XclAddressConverterBase( rRoot.GetTracer(), rRoot.GetScMaxPos() )
56 {
57 }
58
59 // cell address ---------------------------------------------------------------
60
61 bool XclImpAddressConverter::CheckAddress( const XclAddress& rXclPos, bool bWarn )
62 {
63 bool bValidCol = rXclPos.mnCol <= mnMaxCol;
64 bool bValidRow = rXclPos.mnRow <= mnMaxRow;
65 bool bValid = bValidCol && bValidRow;
66 if( !bValid && bWarn )
67 {
68 mbColTrunc |= !bValidCol;
69 mbRowTrunc |= !bValidRow;
70 mrTracer.TraceInvalidAddress( ScAddress(
71 static_cast< SCCOL >( rXclPos.mnCol ), static_cast< SCROW >( rXclPos.mnRow ), 0 ), maMaxPos );
72 }
73 return bValid;
74 }
75
76 bool XclImpAddressConverter::ConvertAddress( ScAddress& rScPos,
77 const XclAddress& rXclPos, SCTAB nScTab, bool bWarn )
78 {
79 bool bValid = CheckAddress( rXclPos, bWarn );
80 if( bValid )
81 lclFillAddress( rScPos, rXclPos.mnCol, rXclPos.mnRow, nScTab );
82 return bValid;
83 }
84
85 ScAddress XclImpAddressConverter::CreateValidAddress(
86 const XclAddress& rXclPos, SCTAB nScTab, bool bWarn )
87 {
88 ScAddress aScPos( ScAddress::UNINITIALIZED );
89 if( !ConvertAddress( aScPos, rXclPos, nScTab, bWarn ) )
90 {
91 aScPos.SetCol( static_cast< SCCOL >( ::std::min( rXclPos.mnCol, mnMaxCol ) ) );
92 aScPos.SetRow( static_cast< SCROW >( ::std::min( rXclPos.mnRow, mnMaxRow ) ) );
93 aScPos.SetTab( limit_cast< SCTAB >( nScTab, 0, maMaxPos.Tab() ) );
94 }
95 return aScPos;
96 }
97
98 // cell range -----------------------------------------------------------------
99
100 bool XclImpAddressConverter::ConvertRange( ScRange& rScRange,
101 const XclRange& rXclRange, SCTAB nScTab1, SCTAB nScTab2, bool bWarn )
102 {
103 // check start position
104 bool bValidStart = CheckAddress( rXclRange.maFirst, bWarn );
105 if( bValidStart )
106 {
107 lclFillAddress( rScRange.aStart, rXclRange.maFirst.mnCol, rXclRange.maFirst.mnRow, nScTab1 );
108
109 // check & correct end position
110 sal_uInt16 nXclCol2 = rXclRange.maLast.mnCol;
111 sal_uInt32 nXclRow2 = rXclRange.maLast.mnRow;
112 if( !CheckAddress( rXclRange.maLast, bWarn ) )
113 {
114 nXclCol2 = ::std::min( nXclCol2, mnMaxCol );
115 nXclRow2 = ::std::min( nXclRow2, mnMaxRow );
116 }
117 lclFillAddress( rScRange.aEnd, nXclCol2, nXclRow2, nScTab2 );
118 }
119 return bValidStart;
120 }
121
122 // cell range list ------------------------------------------------------------
123
124 void XclImpAddressConverter::ConvertRangeList( ScRangeList& rScRanges,
125 const XclRangeList& rXclRanges, SCTAB nScTab, bool bWarn )
126 {
127 rScRanges.RemoveAll();
128 for( XclRangeList::const_iterator aIt = rXclRanges.begin(), aEnd = rXclRanges.end(); aIt != aEnd; ++aIt )
129 {
130 ScRange aScRange( ScAddress::UNINITIALIZED );
131 if( ConvertRange( aScRange, *aIt, nScTab, nScTab, bWarn ) )
132 rScRanges.Append( aScRange );
133 }
134 }
135
136 // String->EditEngine conversion ==============================================
137
138 namespace {
139
140 EditTextObject* lclCreateTextObject( const XclImpRoot& rRoot,
141 const XclImpString& rString, XclFontItemType eType, sal_uInt16 nXFIndex )
142 {
143 EditTextObject* pTextObj = 0;
144
145 const XclImpXFBuffer& rXFBuffer = rRoot.GetXFBuffer();
146 const XclImpFont* pFirstFont = rXFBuffer.GetFont( nXFIndex );
147 bool bFirstEscaped = pFirstFont && pFirstFont->HasEscapement();
148
149 if( rString.IsRich() || bFirstEscaped )
150 {
151 const XclImpFontBuffer& rFontBuffer = rRoot.GetFontBuffer();
152 const XclFormatRunVec& rFormats = rString.GetFormats();
153
154 ScEditEngineDefaulter& rEE = (eType == EXC_FONTITEM_NOTE) ?
155 static_cast< ScEditEngineDefaulter& >( rRoot.GetDoc().GetNoteEngine() ) : rRoot.GetEditEngine();
156 rEE.SetText( rString.GetText() );
157
158 SfxItemSet aItemSet( rEE.GetEmptyItemSet() );
159 if( bFirstEscaped )
160 rFontBuffer.FillToItemSet( aItemSet, eType, rXFBuffer.GetFontIndex( nXFIndex ) );
161 ESelection aSelection;
162
163 XclFormatRun aNextRun;
164 XclFormatRunVec::const_iterator aIt = rFormats.begin();
165 XclFormatRunVec::const_iterator aEnd = rFormats.end();
166
167 if( aIt != aEnd )
168 aNextRun = *aIt++;
169 else
170 aNextRun.mnChar = 0xFFFF;
171
172 xub_StrLen nLen = rString.GetText().Len();
173 for( sal_uInt16 nChar = 0; nChar < nLen; ++nChar )
174 {
175 // reached new different formatted text portion
176 if( nChar >= aNextRun.mnChar )
177 {
178 // send items to edit engine
179 rEE.QuickSetAttribs( aItemSet, aSelection );
180
181 // start new item set
182 aItemSet.ClearItem();
183 rFontBuffer.FillToItemSet( aItemSet, eType, aNextRun.mnFontIdx );
184
185 // read new formatting information
186 if( aIt != aEnd )
187 aNextRun = *aIt++;
188 else
189 aNextRun.mnChar = 0xFFFF;
190
191 // reset selection start to current position
192 aSelection.nStartPara = aSelection.nEndPara;
193 aSelection.nStartPos = aSelection.nEndPos;
194 }
195
196 // set end of selection to current position
197 if( rString.GetText().GetChar( nChar ) == '\n' )
198 {
199 ++aSelection.nEndPara;
200 aSelection.nEndPos = 0;
201 }
202 else
203 ++aSelection.nEndPos;
204 }
205
206 // send items of last text portion to edit engine
207 rEE.QuickSetAttribs( aItemSet, aSelection );
208
209 pTextObj = rEE.CreateTextObject();
210 }
211
212 return pTextObj;
213 }
214
215 } // namespace
216
217 EditTextObject* XclImpStringHelper::CreateTextObject(
218 const XclImpRoot& rRoot, const XclImpString& rString )
219 {
220 return lclCreateTextObject( rRoot, rString, EXC_FONTITEM_EDITENG, 0 );
221 }
222
223 ScBaseCell* XclImpStringHelper::CreateCell(
224 const XclImpRoot& rRoot, const XclImpString& rString, sal_uInt16 nXFIndex )
225 {
226 ScBaseCell* pCell = 0;
227
228 if( rString.GetText().Len() )
229 {
230 ::std::auto_ptr< EditTextObject > pTextObj( lclCreateTextObject( rRoot, rString, EXC_FONTITEM_EDITENG, nXFIndex ) );
231 ScDocument& rDoc = rRoot.GetDoc();
232
233 if( pTextObj.get() )
234 // ScEditCell creates own copy of text object
235 pCell = new ScEditCell( pTextObj.get(), &rDoc, rRoot.GetEditEngine().GetEditTextObjectPool() );
236 else
237 pCell = ScBaseCell::CreateTextCell( rString.GetText(), &rDoc );
238 }
239
240 return pCell;
241 }
242
243 // Header/footer conversion ===================================================
244
245 XclImpHFConverter::XclImpHFPortionInfo::XclImpHFPortionInfo() :
246 mnHeight( 0 ),
247 mnMaxLineHt( 0 )
248 {
249 maSel.nStartPara = maSel.nEndPara = 0;
250 maSel.nStartPos = maSel.nEndPos = 0;
251 }
252
253 // ----------------------------------------------------------------------------
254
255 XclImpHFConverter::XclImpHFConverter( const XclImpRoot& rRoot ) :
256 XclImpRoot( rRoot ),
257 mrEE( rRoot.GetHFEditEngine() ),
258 mxFontData( new XclFontData ),
259 meCurrObj( EXC_HF_CENTER )
260 {
261 }
262
263 XclImpHFConverter::~XclImpHFConverter()
264 {
265 }
266
267 void XclImpHFConverter::ParseString( const String& rHFString )
268 {
269 // edit engine objects
270 mrEE.SetText( EMPTY_STRING );
271 maInfos.clear();
272 maInfos.resize( EXC_HF_PORTION_COUNT );
273 meCurrObj = EXC_HF_CENTER;
274
275 // parser temporaries
276 maCurrText.Erase();
277 String aReadFont; // current font name
278 String aReadStyle; // current font style
279 sal_uInt16 nReadHeight = 0; // current font height
280 ResetFontData();
281
282 /** State of the parser. */
283 enum XclHFParserState
284 {
285 xlPSText, /// Read text, search for functions.
286 xlPSFunc, /// Read function (token following a '&').
287 xlPSFont, /// Read font name ('&' is followed by '"', reads until next '"' or ',').
288 xlPSFontStyle, /// Read font style name (font part after ',', reads until next '"').
289 xlPSHeight /// Read font height ('&' is followed by num. digits, reads until non-digit).
290 } eState = xlPSText;
291
292 const sal_Unicode* pChar = rHFString.GetBuffer();
293 const sal_Unicode* pNull = pChar + rHFString.Len(); // pointer to teminating null char
294 while( *pChar )
295 {
296 switch( eState )
297 {
298
299 // --- read text character ---
300
301 case xlPSText:
302 {
303 switch( *pChar )
304 {
305 case '&': // new command
306 InsertText();
307 eState = xlPSFunc;
308 break;
309 case '\n': // line break
310 InsertText();
311 InsertLineBreak();
312 break;
313 default:
314 maCurrText += *pChar;
315 }
316 }
317 break;
318
319 // --- read control sequence ---
320
321 case xlPSFunc:
322 {
323 eState = xlPSText;
324 switch( *pChar )
325 {
326 case '&': maCurrText += '&'; break; // the '&' character
327
328 case 'L': SetNewPortion( EXC_HF_LEFT ); break; // Left portion
329 case 'C': SetNewPortion( EXC_HF_CENTER ); break; // Center portion
330 case 'R': SetNewPortion( EXC_HF_RIGHT ); break; // Right portion
331
332 case 'P': InsertField( SvxFieldItem( SvxPageField(), EE_FEATURE_FIELD ) ); break; // page
333 case 'N': InsertField( SvxFieldItem( SvxPagesField(), EE_FEATURE_FIELD ) ); break; // page count
334 case 'D': InsertField( SvxFieldItem( SvxDateField(), EE_FEATURE_FIELD ) ); break; // date
335 case 'T': InsertField( SvxFieldItem( SvxTimeField(), EE_FEATURE_FIELD ) ); break; // time
336 case 'A': InsertField( SvxFieldItem( SvxTableField(), EE_FEATURE_FIELD ) ); break; // table name
337
338 case 'Z': // file path
339 InsertField( SvxFieldItem( SvxExtFileField(), EE_FEATURE_FIELD ) ); // convert to full name
340 if( (pNull - pChar >= 2) && (*(pChar + 1) == '&') && (*(pChar + 2) == 'F') )
341 {
342 // &Z&F found - ignore the &F part
343 pChar += 2;
344 }
345 break;
346 case 'F': // file name
347 InsertField( SvxFieldItem( SvxExtFileField( EMPTY_STRING, SVXFILETYPE_VAR, SVXFILEFORMAT_NAME_EXT ), EE_FEATURE_FIELD ) );
348 break;
349
350 case 'U': // underline
351 SetAttribs();
352 mxFontData->mnUnderline = (mxFontData->mnUnderline == EXC_FONTUNDERL_SINGLE) ?
353 EXC_FONTUNDERL_NONE : EXC_FONTUNDERL_SINGLE;
354 break;
355 case 'E': // double underline
356 SetAttribs();
357 mxFontData->mnUnderline = (mxFontData->mnUnderline == EXC_FONTUNDERL_DOUBLE) ?
358 EXC_FONTUNDERL_NONE : EXC_FONTUNDERL_DOUBLE;
359 break;
360 case 'S': // strikeout
361 SetAttribs();
362 mxFontData->mbStrikeout = !mxFontData->mbStrikeout;
363 break;
364 case 'X': // superscript
365 SetAttribs();
366 mxFontData->mnEscapem = (mxFontData->mnEscapem == EXC_FONTESC_SUPER) ?
367 EXC_FONTESC_NONE : EXC_FONTESC_SUPER;
368 break;
369 case 'Y': // subsrcipt
370 SetAttribs();
371 mxFontData->mnEscapem = (mxFontData->mnEscapem == EXC_FONTESC_SUB) ?
372 EXC_FONTESC_NONE : EXC_FONTESC_SUB;
373 break;
374
375 case '\"': // font name
376 aReadFont.Erase();
377 aReadStyle.Erase();
378 eState = xlPSFont;
379 break;
380 default:
381 if( ('0' <= *pChar) && (*pChar <= '9') ) // font size
382 {
383 nReadHeight = *pChar - '0';
384 eState = xlPSHeight;
385 }
386 }
387 }
388 break;
389
390 // --- read font name ---
391
392 case xlPSFont:
393 {
394 switch( *pChar )
395 {
396 case '\"':
397 --pChar;
398 // run through
399 case ',':
400 eState = xlPSFontStyle;
401 break;
402 default:
403 aReadFont += *pChar;
404 }
405 }
406 break;
407
408 // --- read font style ---
409
410 case xlPSFontStyle:
411 {
412 switch( *pChar )
413 {
414 case '\"':
415 SetAttribs();
416 if( aReadFont.Len() )
417 mxFontData->maName = aReadFont;
418 mxFontData->maStyle = aReadStyle;
419 eState = xlPSText;
420 break;
421 default:
422 aReadStyle += *pChar;
423 }
424 }
425 break;
426
427 // --- read font height ---
428
429 case xlPSHeight:
430 {
431 if( ('0' <= *pChar) && (*pChar <= '9') )
432 {
433 if( nReadHeight != 0xFFFF )
434 {
435 nReadHeight *= 10;
436 nReadHeight += (*pChar - '0');
437 if( nReadHeight > 1600 ) // max 1600pt = 32000twips
438 nReadHeight = 0xFFFF;
439 }
440 }
441 else
442 {
443 if( (nReadHeight != 0) && (nReadHeight != 0xFFFF) )
444 {
445 SetAttribs();
446 mxFontData->mnHeight = nReadHeight * 20;
447 }
448 --pChar;
449 eState = xlPSText;
450 }
451 }
452 break;
453 }
454 ++pChar;
455 }
456
457 // finalize
458 CreateCurrObject();
459 maInfos[ EXC_HF_LEFT ].mnHeight += GetMaxLineHeight( EXC_HF_LEFT );
460 maInfos[ EXC_HF_CENTER ].mnHeight += GetMaxLineHeight( EXC_HF_CENTER );
461 maInfos[ EXC_HF_RIGHT ].mnHeight += GetMaxLineHeight( EXC_HF_RIGHT );
462 }
463
464 void XclImpHFConverter::FillToItemSet( SfxItemSet& rItemSet, sal_uInt16 nWhichId ) const
465 {
466 ScPageHFItem aHFItem( nWhichId );
467 if( maInfos[ EXC_HF_LEFT ].mxObj.get() )
468 aHFItem.SetLeftArea( *maInfos[ EXC_HF_LEFT ].mxObj );
469 if( maInfos[ EXC_HF_CENTER ].mxObj.get() )
470 aHFItem.SetCenterArea( *maInfos[ EXC_HF_CENTER ].mxObj );
471 if( maInfos[ EXC_HF_RIGHT ].mxObj.get() )
472 aHFItem.SetRightArea( *maInfos[ EXC_HF_RIGHT ].mxObj );
473 rItemSet.Put( aHFItem );
474 }
475
476 sal_Int32 XclImpHFConverter::GetTotalHeight() const
477 {
478 return ::std::max( maInfos[ EXC_HF_LEFT ].mnHeight,
479 ::std::max( maInfos[ EXC_HF_CENTER ].mnHeight, maInfos[ EXC_HF_RIGHT ].mnHeight ) );
480 }
481
482 // private --------------------------------------------------------------------
483
484 sal_uInt16 XclImpHFConverter::GetMaxLineHeight( XclImpHFPortion ePortion ) const
485 {
486 sal_uInt16 nMaxHt = maInfos[ ePortion ].mnMaxLineHt;
487 return (nMaxHt == 0) ? mxFontData->mnHeight : nMaxHt;
488 }
489
490 sal_uInt16 XclImpHFConverter::GetCurrMaxLineHeight() const
491 {
492 return GetMaxLineHeight( meCurrObj );
493 }
494
495 void XclImpHFConverter::UpdateMaxLineHeight( XclImpHFPortion ePortion )
496 {
497 sal_uInt16& rnMaxHt = maInfos[ ePortion ].mnMaxLineHt;
498 rnMaxHt = ::std::max( rnMaxHt, mxFontData->mnHeight );
499 }
500
501 void XclImpHFConverter::UpdateCurrMaxLineHeight()
502 {
503 UpdateMaxLineHeight( meCurrObj );
504 }
505
506 void XclImpHFConverter::SetAttribs()
507 {
508 ESelection& rSel = GetCurrSel();
509 if( (rSel.nStartPara != rSel.nEndPara) || (rSel.nStartPos != rSel.nEndPos) )
510 {
511 SfxItemSet aItemSet( mrEE.GetEmptyItemSet() );
512 XclImpFont aFont( GetRoot(), *mxFontData );
513 aFont.FillToItemSet( aItemSet, EXC_FONTITEM_HF );
514 mrEE.QuickSetAttribs( aItemSet, rSel );
515 rSel.nStartPara = rSel.nEndPara;
516 rSel.nStartPos = rSel.nEndPos;
517 }
518 }
519
520 void XclImpHFConverter::ResetFontData()
521 {
522 if( const XclImpFont* pFirstFont = GetFontBuffer().GetFont( EXC_FONT_APP ) )
523 *mxFontData = pFirstFont->GetFontData();
524 else
525 {
526 mxFontData->Clear();
527 mxFontData->mnHeight = 200;
528 }
529 }
530
531 void XclImpHFConverter::InsertText()
532 {
533 if( maCurrText.Len() )
534 {
535 ESelection& rSel = GetCurrSel();
536 mrEE.QuickInsertText( maCurrText, ESelection( rSel.nEndPara, rSel.nEndPos, rSel.nEndPara, rSel.nEndPos ) );
537 rSel.nEndPos = rSel.nEndPos + maCurrText.Len();
538 maCurrText.Erase();
539 UpdateCurrMaxLineHeight();
540 }
541 }
542
543 void XclImpHFConverter::InsertField( const SvxFieldItem& rFieldItem )
544 {
545 ESelection& rSel = GetCurrSel();
546 mrEE.QuickInsertField( rFieldItem, ESelection( rSel.nEndPara, rSel.nEndPos, rSel.nEndPara, rSel.nEndPos ) );
547 ++rSel.nEndPos;
548 UpdateCurrMaxLineHeight();
549 }
550
551 void XclImpHFConverter::InsertLineBreak()
552 {
553 ESelection& rSel = GetCurrSel();
554 mrEE.QuickInsertText( rtl::OUString('\n'), ESelection( rSel.nEndPara, rSel.nEndPos, rSel.nEndPara, rSel.nEndPos ) );
555 ++rSel.nEndPara;
556 rSel.nEndPos = 0;
557 GetCurrInfo().mnHeight += GetCurrMaxLineHeight();
558 GetCurrInfo().mnMaxLineHt = 0;
559 }
560
561 void XclImpHFConverter::CreateCurrObject()
562 {
563 InsertText();
564 SetAttribs();
565 GetCurrObj().reset( mrEE.CreateTextObject() );
566 }
567
568 void XclImpHFConverter::SetNewPortion( XclImpHFPortion eNew )
569 {
570 if( eNew != meCurrObj )
571 {
572 CreateCurrObject();
573 meCurrObj = eNew;
574 if( GetCurrObj().get() )
575 mrEE.SetText( *GetCurrObj() );
576 else
577 mrEE.SetText( EMPTY_STRING );
578 ResetFontData();
579 }
580 }
581
582 // URL conversion =============================================================
583
584 namespace {
585
586 void lclAppendUrlChar( String& rUrl, sal_Unicode cChar )
587 {
588 // encode special characters
589 switch( cChar )
590 {
591 case '#': rUrl.AppendAscii( "%23" ); break;
592 case '%': rUrl.AppendAscii( "%25" ); break;
593 default: rUrl.Append( cChar );
594 }
595 }
596
597 } // namespace
598
599 void XclImpUrlHelper::DecodeUrl(
600 String& rUrl, String& rTabName, bool& rbSameWb,
601 const XclImpRoot& rRoot, const String& rEncodedUrl )
602 {
603 enum
604 {
605 xlUrlInit, /// Initial state, read string mode character.
606 xlUrlPath, /// Read URL path.
607 xlUrlFileName, /// Read file name.
608 xlUrlSheetName, /// Read sheet name.
609 xlUrlRaw /// Raw mode. No control characters will occur.
610 } eState = xlUrlInit;
611
612 bool bEncoded = true;
613 rbSameWb = false;
614
615 sal_Unicode cCurrDrive = 0;
616 String aDosBase( INetURLObject( rRoot.GetBasePath() ).getFSysPath( INetURLObject::FSYS_DOS ) );
617 if( (aDosBase.Len() > 2) && aDosBase.EqualsAscii( ":\\", 1, 2 ) )
618 cCurrDrive = aDosBase.GetChar( 0 );
619
620 const sal_Unicode* pChar = rEncodedUrl.GetBuffer();
621 while( *pChar )
622 {
623 switch( eState )
624 {
625
626 // --- first character ---
627
628 case xlUrlInit:
629 {
630 switch( *pChar )
631 {
632 case EXC_URLSTART_ENCODED:
633 eState = xlUrlPath;
634 break;
635 case EXC_URLSTART_SELF:
636 case EXC_URLSTART_SELFENCODED:
637 rbSameWb = true;
638 eState = xlUrlSheetName;
639 break;
640 case '[':
641 bEncoded = false;
642 eState = xlUrlFileName;
643 break;
644 default:
645 bEncoded = false;
646 lclAppendUrlChar( rUrl, *pChar );
647 eState = xlUrlPath;
648 }
649 }
650 break;
651
652 // --- URL path ---
653
654 case xlUrlPath:
655 {
656 switch( *pChar )
657 {
658 case EXC_URL_DOSDRIVE:
659 {
660 if( *(pChar + 1) )
661 {
662 ++pChar;
663 if( *pChar == '@' )
664 rUrl.AppendAscii( "\\\\" );
665 else
666 {
667 lclAppendUrlChar( rUrl, *pChar );
668 rUrl.AppendAscii( ":\\" );
669 }
670 }
671 else
672 rUrl.AppendAscii( "<NULL-DRIVE!>" );
673 }
674 break;
675 case EXC_URL_DRIVEROOT:
676 if( cCurrDrive )
677 {
678 lclAppendUrlChar( rUrl, cCurrDrive );
679 rUrl.Append( ':' );
680 }
681 // run through
682 case EXC_URL_SUBDIR:
683 if( bEncoded )
684 rUrl.Append( '\\' );
685 else // control character in raw name -> DDE link
686 {
687 rUrl.Append( EXC_DDE_DELIM );
688 eState = xlUrlRaw;
689 }
690 break;
691 case EXC_URL_PARENTDIR:
692 rUrl.AppendAscii( "..\\" );
693 break;
694 case EXC_URL_RAW:
695 {
696 if( *(pChar + 1) )
697 {
698 xub_StrLen nLen = *++pChar;
699 for( xub_StrLen nChar = 0; (nChar < nLen) && *(pChar + 1); ++nChar )
700 lclAppendUrlChar( rUrl, *++pChar );
701 // rUrl.Append( ':' );
702 }
703 }
704 break;
705 case '[':
706 eState = xlUrlFileName;
707 break;
708 default:
709 lclAppendUrlChar( rUrl, *pChar );
710 }
711 }
712 break;
713
714 // --- file name ---
715
716 case xlUrlFileName:
717 {
718 switch( *pChar )
719 {
720 case ']': eState = xlUrlSheetName; break;
721 default: lclAppendUrlChar( rUrl, *pChar );
722 }
723 }
724 break;
725
726 // --- sheet name ---
727
728 case xlUrlSheetName:
729 rTabName.Append( *pChar );
730 break;
731
732 // --- raw read mode ---
733
734 case xlUrlRaw:
735 lclAppendUrlChar( rUrl, *pChar );
736 break;
737 }
738
739 ++pChar;
740 }
741 }
742
743 void XclImpUrlHelper::DecodeUrl(
744 String& rUrl, bool& rbSameWb, const XclImpRoot& rRoot, const String& rEncodedUrl )
745 {
746 String aTabName;
747 DecodeUrl( rUrl, aTabName, rbSameWb, rRoot, rEncodedUrl );
748 OSL_ENSURE( !aTabName.Len(), "XclImpUrlHelper::DecodeUrl - sheet name ignored" );
749 }
750
751 void XclImpUrlHelper::DecodeUrl(
752 ::rtl::OUString& rUrl, bool& rbSameWb, const XclImpRoot& rRoot, const ::rtl::OUString& rEncodedUrl )
753 {
754 String aTabName;
755 String aUrl;
756 DecodeUrl( aUrl, aTabName, rbSameWb, rRoot, rEncodedUrl );
757 rUrl = aUrl;
758 OSL_ENSURE( !aTabName.Len(), "XclImpUrlHelper::DecodeUrl - sheet name ignored" );
759 }
760
761 bool XclImpUrlHelper::DecodeLink( String& rApplic, String& rTopic, const String rEncUrl )
762 {
763 xub_StrLen nPos = rEncUrl.Search( EXC_DDE_DELIM );
764 if( (nPos != STRING_NOTFOUND) && (0 < nPos) && (nPos + 1 < rEncUrl.Len()) )
765 {
766 rApplic = rEncUrl.Copy( 0, nPos );
767 rTopic = rEncUrl.Copy( nPos + 1 );
768 return true;
769 }
770 return false;
771 }
772
773 // Cached Values ==============================================================
774
775 XclImpCachedValue::XclImpCachedValue( XclImpStream& rStrm ) :
776 mfValue( 0.0 ),
777 mnBoolErr( 0 )
778 {
779 rStrm >> mnType;
780 switch( mnType )
781 {
782 case EXC_CACHEDVAL_EMPTY:
783 rStrm.Ignore( 8 );
784 break;
785 case EXC_CACHEDVAL_DOUBLE:
786 rStrm >> mfValue;
787 break;
788 case EXC_CACHEDVAL_STRING:
789 mxStr.reset( new String( rStrm.ReadUniString() ) );
790 break;
791 case EXC_CACHEDVAL_BOOL:
792 case EXC_CACHEDVAL_ERROR:
793 {
794 double fVal;
795 rStrm >> mnBoolErr;
796 rStrm.Ignore( 7 );
797
798 const ScTokenArray* pScTokArr = rStrm.GetRoot().GetOldFmlaConverter().GetBoolErr(
799 XclTools::ErrorToEnum( fVal, mnType == EXC_CACHEDVAL_ERROR, mnBoolErr ) );
800 if( pScTokArr )
801 mxTokArr.reset( pScTokArr->Clone() );
802 }
803 break;
804 default:
805 OSL_FAIL( "XclImpCachedValue::XclImpCachedValue - unknown data type" );
806 }
807 }
808
809 XclImpCachedValue::~XclImpCachedValue()
810 {
811 }
812
813 sal_uInt16 XclImpCachedValue::GetScError() const
814 {
815 return (mnType == EXC_CACHEDVAL_ERROR) ? XclTools::GetScErrorCode( mnBoolErr ) : 0;
816 }
817
818 // Matrix Cached Values ==============================================================
819
820 XclImpCachedMatrix::XclImpCachedMatrix( XclImpStream& rStrm ) :
821 mnScCols( 0 ),
822 mnScRows( 0 )
823 {
824 mnScCols = rStrm.ReaduInt8();
825 mnScRows = rStrm.ReaduInt16();
826
827 if( rStrm.GetRoot().GetBiff() <= EXC_BIFF5 )
828 {
829 // in BIFF2-BIFF7: 256 columns represented by 0 columns
830 if( mnScCols == 0 )
831 mnScCols = 256;
832 }
833 else
834 {
835 // in BIFF8: columns and rows decreaed by 1
836 ++mnScCols;
837 ++mnScRows;
838 }
839
840 for( SCSIZE nScRow = 0; nScRow < mnScRows; ++nScRow )
841 for( SCSIZE nScCol = 0; nScCol < mnScCols; ++nScCol )
842 maValueList.push_back( new XclImpCachedValue( rStrm ) );
843 }
844
845 XclImpCachedMatrix::~XclImpCachedMatrix()
846 {
847 }
848
849 ScMatrixRef XclImpCachedMatrix::CreateScMatrix() const
850 {
851 ScMatrixRef xScMatrix;
852 OSL_ENSURE( mnScCols * mnScRows == maValueList.size(), "XclImpCachedMatrix::CreateScMatrix - element count mismatch" );
853 if( mnScCols && mnScRows && static_cast< sal_uLong >( mnScCols * mnScRows ) <= maValueList.size() )
854 {
855 xScMatrix = new ScMatrix(mnScCols, mnScRows, 0.0);
856 XclImpValueList::const_iterator itValue = maValueList.begin();
857 for( SCSIZE nScRow = 0; nScRow < mnScRows; ++nScRow )
858 {
859 for( SCSIZE nScCol = 0; nScCol < mnScCols; ++nScCol )
860 {
861 switch( itValue->GetType() )
862 {
863 case EXC_CACHEDVAL_EMPTY:
864 // Excel shows 0.0 here, not an empty cell
865 xScMatrix->PutEmpty( nScCol, nScRow );
866 break;
867 case EXC_CACHEDVAL_DOUBLE:
868 xScMatrix->PutDouble( itValue->GetValue(), nScCol, nScRow );
869 break;
870 case EXC_CACHEDVAL_STRING:
871 xScMatrix->PutString( itValue->GetString(), nScCol, nScRow );
872 break;
873 case EXC_CACHEDVAL_BOOL:
874 xScMatrix->PutBoolean( itValue->GetBool(), nScCol, nScRow );
875 break;
876 case EXC_CACHEDVAL_ERROR:
877 xScMatrix->PutError( itValue->GetScError(), nScCol, nScRow );
878 break;
879 default:
880 OSL_FAIL( "XclImpCachedMatrix::CreateScMatrix - unknown value type" );
881 xScMatrix->PutEmpty( nScCol, nScRow );
882 }
883 ++itValue;
884 }
885 }
886 }
887 return xScMatrix;
888 }
889
890 // ============================================================================
891
892 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE