1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_editeng.hxx"
26
27 #include <svl/intitem.hxx>
28 #include <editeng/editeng.hxx>
29 #include <editeng/editview.hxx>
30 #include <editeng/editdata.hxx>
31 #include <editeng/eerdll.hxx>
32 #include <editeng/lrspitem.hxx>
33 #include <editeng/fhgtitem.hxx>
34
35 #include <math.h>
36 #include <svl/style.hxx>
37 #include <vcl/wrkwin.hxx>
38 #define _OUTLINER_CXX
39 #include <editeng/outliner.hxx>
40 #include <paralist.hxx>
41 #include <editeng/outlobj.hxx>
42 #include <outleeng.hxx>
43 #include <outlundo.hxx>
44 #include <editeng/eeitem.hxx>
45 #include <editeng/editstat.hxx>
46 #include <editeng/scripttypeitem.hxx>
47 #include <editeng/editobj.hxx>
48 #include <svl/itemset.hxx>
49 #include <svl/whiter.hxx>
50 #include <vcl/metric.hxx>
51 #include <editeng/numitem.hxx>
52 #include <editeng/adjitem.hxx>
53 #include <vcl/graph.hxx>
54 #include <vcl/gdimtf.hxx>
55 #include <vcl/metaact.hxx>
56 #include <svtools/grfmgr.hxx>
57 #include <editeng/svxfont.hxx>
58 #include <editeng/brshitem.hxx>
59 #include <svl/itempool.hxx>
60
61 // #101498# calculate if it's RTL or not
62 #include <unicode/ubidi.h>
63
64 #define DEFAULT_SCALE 75
65
66 static const sal_uInt16 nDefStyles = 3; // Sonderbehandlung fuer die ersten 3 Ebenen
67 static const sal_uInt16 nDefBulletIndent = 800;
68 static const sal_uInt16 nDefBulletWidth = 700;
69 static const sal_uInt16 pDefBulletIndents[nDefStyles]= { 1400, 800, 800 };
70 static const sal_uInt16 pDefBulletWidths[nDefStyles] = { 1000, 850, 700 };
71
lcl_ImplGetDefBulletWidth(sal_Int16 nDepth)72 sal_uInt16 lcl_ImplGetDefBulletWidth( sal_Int16 nDepth )
73 {
74 return ( nDepth < nDefStyles ) ? pDefBulletWidths[nDepth] : nDefBulletWidth;
75 }
76
lcl_ImplGetDefBulletIndent(sal_Int16 nDepth)77 sal_uInt16 lcl_ImplGetDefBulletIndent( sal_Int16 nDepth )
78 {
79 sal_uInt16 nI = 0;
80
81 if( nDepth >= 0 )
82 {
83 for ( sal_Int16 n = 0; n <= nDepth; n++ )
84 nI = nI +
85 ( ( n < nDefStyles ) ? pDefBulletIndents[n] : nDefBulletIndent );
86 }
87 return nI;
88 }
89
90
91 // ----------------------------------------------------------------------
92 // Outliner
93 // ----------------------------------------------------------------------
94 DBG_NAME(Outliner);
95
ImplCheckDepth(sal_Int16 & rnDepth) const96 void Outliner::ImplCheckDepth( sal_Int16& rnDepth ) const
97 {
98 if( rnDepth < nMinDepth )
99 rnDepth = nMinDepth;
100 else if( rnDepth > nMaxDepth )
101 rnDepth = nMaxDepth;
102 }
103
Insert(const XubString & rText,sal_uLong nAbsPos,sal_Int16 nDepth)104 Paragraph* Outliner::Insert(const XubString& rText, sal_uLong nAbsPos, sal_Int16 nDepth)
105 {
106 DBG_CHKTHIS(Outliner,0);
107 DBG_ASSERT(pParaList->GetParagraphCount(),"Insert:No Paras");
108
109 Paragraph* pPara;
110
111 ImplCheckDepth( nDepth );
112
113 sal_uLong nParagraphCount = pParaList->GetParagraphCount();
114 if( nAbsPos > nParagraphCount )
115 nAbsPos = nParagraphCount;
116
117 if( bFirstParaIsEmpty )
118 {
119 pPara = pParaList->GetParagraph( 0 );
120 if( pPara->GetDepth() != nDepth )
121 {
122 nDepthChangedHdlPrevDepth = pPara->GetDepth();
123 mnDepthChangeHdlPrevFlags = pPara->nFlags;
124 pPara->SetDepth( nDepth );
125 pHdlParagraph = pPara;
126 DepthChangedHdl();
127 }
128 pPara->nFlags |= PARAFLAG_HOLDDEPTH;
129 SetText( rText, pPara );
130 }
131 else
132 {
133 sal_Bool bUpdate = pEditEngine->GetUpdateMode();
134 pEditEngine->SetUpdateMode( sal_False );
135 ImplBlockInsertionCallbacks( sal_True );
136 pPara = new Paragraph( nDepth );
137 pParaList->Insert( pPara, nAbsPos );
138 pEditEngine->InsertParagraph( (sal_uInt16)nAbsPos, String() );
139 DBG_ASSERT(pPara==pParaList->GetParagraph(nAbsPos),"Insert:Failed");
140 ImplInitDepth( (sal_uInt16)nAbsPos, nDepth, sal_False );
141 pHdlParagraph = pPara;
142 ParagraphInsertedHdl();
143 pPara->nFlags |= PARAFLAG_HOLDDEPTH;
144 SetText( rText, pPara );
145 ImplBlockInsertionCallbacks( sal_False );
146 pEditEngine->SetUpdateMode( bUpdate );
147 }
148 bFirstParaIsEmpty = sal_False;
149 DBG_ASSERT(pEditEngine->GetParagraphCount()==pParaList->GetParagraphCount(),"SetText failed");
150 return pPara;
151 }
152
153
ParagraphInserted(sal_uInt16 nPara)154 void Outliner::ParagraphInserted( sal_uInt16 nPara )
155 {
156 DBG_CHKTHIS(Outliner,0);
157
158 if ( bBlockInsCallback )
159 return;
160
161 if( bPasting || pEditEngine->IsInUndo() )
162 {
163 Paragraph* pPara = new Paragraph( -1 );
164 pParaList->Insert( pPara, nPara );
165 if( pEditEngine->IsInUndo() )
166 {
167 pPara->nFlags = PARAFLAG_SETBULLETTEXT;
168 pPara->bVisible = sal_True;
169 const SfxInt16Item& rLevel = (const SfxInt16Item&) pEditEngine->GetParaAttrib( nPara, EE_PARA_OUTLLEVEL );
170 pPara->SetDepth( rLevel.GetValue() );
171 }
172 }
173 else
174 {
175 sal_Int16 nDepth = -1;
176 Paragraph* pParaBefore = pParaList->GetParagraph( nPara-1 );
177 if ( pParaBefore )
178 nDepth = pParaBefore->GetDepth();
179
180 Paragraph* pPara = new Paragraph( nDepth );
181 pParaList->Insert( pPara, nPara );
182
183 if( !pEditEngine->IsInUndo() )
184 {
185 ImplCalcBulletText( nPara, sal_True, sal_False );
186 pHdlParagraph = pPara;
187 ParagraphInsertedHdl();
188 }
189 }
190 }
191
ParagraphDeleted(sal_uInt16 nPara)192 void Outliner::ParagraphDeleted( sal_uInt16 nPara )
193 {
194 DBG_CHKTHIS(Outliner,0);
195
196 if ( bBlockInsCallback || ( nPara == EE_PARA_ALL ) )
197 return;
198
199 Paragraph* pPara = pParaList->GetParagraph( nPara );
200 if (!pPara)
201 return;
202
203 sal_Int16 nDepth = pPara->GetDepth();
204
205 if( !pEditEngine->IsInUndo() )
206 {
207 pHdlParagraph = pPara;
208 ParagraphRemovingHdl();
209 }
210
211 pParaList->Remove( nPara );
212 delete pPara;
213
214 if( !pEditEngine->IsInUndo() && !bPasting )
215 {
216 pPara = pParaList->GetParagraph( nPara );
217 if ( pPara && ( pPara->GetDepth() > nDepth ) )
218 {
219 ImplCalcBulletText( nPara, sal_True, sal_False );
220 // naechsten auf gleicher Ebene suchen...
221 while ( pPara && pPara->GetDepth() > nDepth )
222 pPara = pParaList->GetParagraph( ++nPara );
223 }
224
225 if ( pPara && ( pPara->GetDepth() == nDepth ) )
226 ImplCalcBulletText( nPara, sal_True, sal_False );
227 }
228 }
229
Init(sal_uInt16 nMode)230 void Outliner::Init( sal_uInt16 nMode )
231 {
232 nOutlinerMode = nMode;
233
234 Clear();
235
236 sal_uLong nCtrl = pEditEngine->GetControlWord();
237 nCtrl &= ~(EE_CNTRL_OUTLINER|EE_CNTRL_OUTLINER2);
238
239 SetMaxDepth( 9 );
240
241 switch ( ImplGetOutlinerMode() )
242 {
243 case OUTLINERMODE_TEXTOBJECT:
244 case OUTLINERMODE_TITLEOBJECT:
245 break;
246
247 case OUTLINERMODE_OUTLINEOBJECT:
248 nCtrl |= EE_CNTRL_OUTLINER2;
249 break;
250 case OUTLINERMODE_OUTLINEVIEW:
251 nCtrl |= EE_CNTRL_OUTLINER;
252 break;
253
254 default: DBG_ERROR( "Outliner::Init - Invalid Mode!" );
255 }
256
257 pEditEngine->SetControlWord( nCtrl );
258
259 const bool bWasUndoEnabled(IsUndoEnabled());
260 EnableUndo(false);
261 ImplInitDepth( 0, GetMinDepth(), sal_False );
262 GetUndoManager().Clear();
263 EnableUndo(bWasUndoEnabled);
264 }
265
SetMaxDepth(sal_Int16 nDepth,sal_Bool bCheckParagraphs)266 void Outliner::SetMaxDepth( sal_Int16 nDepth, sal_Bool bCheckParagraphs )
267 {
268 if( nMaxDepth != nDepth )
269 {
270 nMaxDepth = Min( nDepth, (sal_Int16)(SVX_MAX_NUM-1) );
271
272 if( bCheckParagraphs )
273 {
274 sal_uInt16 nParagraphs = (sal_uInt16)pParaList->GetParagraphCount();
275 for ( sal_uInt16 nPara = 0; nPara < nParagraphs; nPara++ )
276 {
277 Paragraph* pPara = pParaList->GetParagraph( nPara );
278 if( pPara && pPara->GetDepth() > nMaxDepth )
279 {
280 SetDepth( pPara, nMaxDepth );
281 }
282 }
283 }
284 }
285 }
286
GetDepth(sal_uLong nPara) const287 sal_Int16 Outliner::GetDepth( sal_uLong nPara ) const
288 {
289 Paragraph* pPara = pParaList->GetParagraph( nPara );
290 DBG_ASSERT( pPara, "Outliner::GetDepth - Paragraph not found!" );
291 return pPara ? pPara->GetDepth() : -1;
292 }
293
SetDepth(Paragraph * pPara,sal_Int16 nNewDepth)294 void Outliner::SetDepth( Paragraph* pPara, sal_Int16 nNewDepth )
295 {
296 DBG_CHKTHIS(Outliner,0);
297
298 ImplCheckDepth( nNewDepth );
299
300 if ( nNewDepth != pPara->GetDepth() )
301 {
302 nDepthChangedHdlPrevDepth = pPara->GetDepth();
303 mnDepthChangeHdlPrevFlags = pPara->nFlags;
304 pHdlParagraph = pPara;
305
306 sal_uInt16 nPara = (sal_uInt16)GetAbsPos( pPara );
307 ImplInitDepth( nPara, nNewDepth, sal_True );
308 ImplCalcBulletText( nPara, sal_False, sal_False );
309
310 if ( ImplGetOutlinerMode() == OUTLINERMODE_OUTLINEOBJECT )
311 ImplSetLevelDependendStyleSheet( nPara );
312
313 DepthChangedHdl();
314 }
315 }
316
GetNumberingStartValue(sal_uInt16 nPara)317 sal_Int16 Outliner::GetNumberingStartValue( sal_uInt16 nPara )
318 {
319 Paragraph* pPara = pParaList->GetParagraph( nPara );
320 DBG_ASSERT( pPara, "Outliner::GetNumberingStartValue - Paragraph not found!" );
321 return pPara ? pPara->GetNumberingStartValue() : -1;
322 }
323
SetNumberingStartValue(sal_uInt16 nPara,sal_Int16 nNumberingStartValue)324 void Outliner::SetNumberingStartValue( sal_uInt16 nPara, sal_Int16 nNumberingStartValue )
325 {
326 Paragraph* pPara = pParaList->GetParagraph( nPara );
327 DBG_ASSERT( pPara, "Outliner::GetNumberingStartValue - Paragraph not found!" );
328 if( pPara && pPara->GetNumberingStartValue() != nNumberingStartValue )
329 {
330 if( IsUndoEnabled() && !IsInUndo() )
331 InsertUndo( new OutlinerUndoChangeParaNumberingRestart( this, nPara,
332 pPara->GetNumberingStartValue(), nNumberingStartValue,
333 pPara->IsParaIsNumberingRestart(), pPara->IsParaIsNumberingRestart() ) );
334
335 pPara->SetNumberingStartValue( nNumberingStartValue );
336 // --> OD 2009-03-10 #i100014#
337 // It is not a good idea to substract 1 from a count and cast the result
338 // to sal_uInt16 without check, if the count is 0.
339 ImplCheckParagraphs( nPara, (sal_uInt16) (pParaList->GetParagraphCount()) );
340 // <--
341 pEditEngine->SetModified();
342 }
343 }
344
IsParaIsNumberingRestart(sal_uInt16 nPara)345 sal_Bool Outliner::IsParaIsNumberingRestart( sal_uInt16 nPara )
346 {
347 Paragraph* pPara = pParaList->GetParagraph( nPara );
348 DBG_ASSERT( pPara, "Outliner::IsParaIsNumberingRestart - Paragraph not found!" );
349 return pPara ? pPara->IsParaIsNumberingRestart() : sal_False;
350 }
351
SetParaIsNumberingRestart(sal_uInt16 nPara,sal_Bool bParaIsNumberingRestart)352 void Outliner::SetParaIsNumberingRestart( sal_uInt16 nPara, sal_Bool bParaIsNumberingRestart )
353 {
354 Paragraph* pPara = pParaList->GetParagraph( nPara );
355 DBG_ASSERT( pPara, "Outliner::SetParaIsNumberingRestart - Paragraph not found!" );
356 if( pPara && (pPara->IsParaIsNumberingRestart() != bParaIsNumberingRestart) )
357 {
358 if( IsUndoEnabled() && !IsInUndo() )
359 InsertUndo( new OutlinerUndoChangeParaNumberingRestart( this, nPara,
360 pPara->GetNumberingStartValue(), pPara->GetNumberingStartValue(),
361 pPara->IsParaIsNumberingRestart(), bParaIsNumberingRestart ) );
362
363 pPara->SetParaIsNumberingRestart( bParaIsNumberingRestart );
364 // --> OD 2009-03-10 #i100014#
365 // It is not a good idea to substract 1 from a count and cast the result
366 // to sal_uInt16 without check, if the count is 0.
367 ImplCheckParagraphs( nPara, (sal_uInt16) (pParaList->GetParagraphCount()) );
368 // <--
369 pEditEngine->SetModified();
370 }
371 }
372
GetBulletsNumberingStatus(const sal_uInt16 nParaStart,const sal_uInt16 nParaEnd) const373 sal_Int16 Outliner::GetBulletsNumberingStatus(
374 const sal_uInt16 nParaStart,
375 const sal_uInt16 nParaEnd ) const
376 {
377 if ( nParaStart > nParaEnd
378 || nParaEnd >= pParaList->GetParagraphCount() )
379 {
380 DBG_ASSERT( false,"<Outliner::GetBulletsNumberingStatus> - unexpected parameter values" );
381 return 2;
382 }
383
384 sal_uInt16 nBulletsCount = 0;
385 sal_uInt16 nNumberingCount = 0;
386 for (sal_uInt16 nPara = nParaStart; nPara <= nParaEnd; nPara++)
387 {
388 if ( !pParaList->GetParagraph(nPara) )
389 {
390 break;
391 }
392 const SvxNumberFormat* pFmt = GetNumberFormat(nPara);
393 if (!pFmt)
394 {
395 // At least, exists one paragraph that has no Bullets/Numbering.
396 break;
397 }
398 else if ((pFmt->GetNumberingType() == SVX_NUM_BITMAP) || (pFmt->GetNumberingType() == SVX_NUM_CHAR_SPECIAL))
399 {
400 // Having Bullets in this paragraph.
401 nBulletsCount++;
402 }
403 else
404 {
405 // Having Numbering in this paragraph.
406 nNumberingCount++;
407 }
408 }
409
410 const sal_uInt16 nParaCount = nParaEnd - nParaStart + 1;
411 if ( nBulletsCount == nParaCount )
412 {
413 return 0;
414 }
415 else if ( nNumberingCount == nParaCount )
416 {
417 return 1;
418 }
419 return 2;
420 }
421
GetBulletsNumberingStatus() const422 sal_Int16 Outliner::GetBulletsNumberingStatus() const
423 {
424 return pParaList->GetParagraphCount() > 0
425 ? GetBulletsNumberingStatus( 0, pParaList->GetParagraphCount()-1 )
426 : 2;
427 }
428
CreateParaObject(sal_uInt16 nStartPara,sal_uInt16 nCount) const429 OutlinerParaObject* Outliner::CreateParaObject( sal_uInt16 nStartPara, sal_uInt16 nCount ) const
430 {
431 DBG_CHKTHIS(Outliner,0);
432
433 if ( sal::static_int_cast< sal_uLong >( nStartPara + nCount ) >
434 pParaList->GetParagraphCount() )
435 nCount = sal::static_int_cast< sal_uInt16 >(
436 pParaList->GetParagraphCount() - nStartPara );
437
438 // When a new OutlinerParaObject is created because a paragraph is just beeing deleted,
439 // it can happen that the ParaList is not updated yet...
440 if ( ( nStartPara + nCount ) > pEditEngine->GetParagraphCount() )
441 nCount = pEditEngine->GetParagraphCount() - nStartPara;
442
443 if( !nCount )
444 return NULL;
445
446 EditTextObject* pText = pEditEngine->CreateTextObject( nStartPara, nCount );
447 const bool bIsEditDoc(OUTLINERMODE_TEXTOBJECT == ImplGetOutlinerMode());
448 ParagraphDataVector aParagraphDataVector(nCount);
449 const sal_uInt16 nLastPara(nStartPara + nCount - 1);
450
451 for(sal_uInt16 nPara(nStartPara); nPara <= nLastPara; nPara++)
452 {
453 aParagraphDataVector[nPara-nStartPara] = *GetParagraph(nPara);
454 }
455
456 OutlinerParaObject* pPObj = new OutlinerParaObject(*pText, aParagraphDataVector, bIsEditDoc);
457 pPObj->SetOutlinerMode(GetMode());
458 delete pText;
459
460 return pPObj;
461 }
462
SetText(const XubString & rText,Paragraph * pPara)463 void Outliner::SetText( const XubString& rText, Paragraph* pPara )
464 {
465 DBG_CHKTHIS(Outliner,0);
466 DBG_ASSERT(pPara,"SetText:No Para");
467
468 sal_Bool bUpdate = pEditEngine->GetUpdateMode();
469 pEditEngine->SetUpdateMode( sal_False );
470 ImplBlockInsertionCallbacks( sal_True );
471
472 sal_uInt16 nPara = (sal_uInt16)pParaList->GetAbsPos( pPara );
473
474 if( !rText.Len() )
475 {
476 pEditEngine->SetText( nPara, rText );
477 ImplInitDepth( nPara, pPara->GetDepth(), sal_False );
478 }
479 else
480 {
481 XubString aText( rText );
482 aText.ConvertLineEnd( LINEEND_LF );
483
484 if( aText.GetChar( aText.Len()-1 ) == '\x0A' )
485 aText.Erase( aText.Len()-1, 1 ); // letzten Umbruch loeschen
486
487 sal_uInt16 nCount = aText.GetTokenCount( '\x0A' );
488 sal_uInt16 nPos = 0;
489 sal_uInt16 nInsPos = nPara+1;
490 while( nCount > nPos )
491 {
492 XubString aStr = aText.GetToken( nPos, '\x0A' );
493
494 sal_Int16 nCurDepth;
495 if( nPos )
496 {
497 pPara = new Paragraph( -1 );
498 nCurDepth = -1;
499 }
500 else
501 nCurDepth = pPara->GetDepth();
502
503 // Im Outliner-Modus die Tabulatoren filtern und die
504 // Einrueckung ueber ein LRSpaceItem einstellen
505 // Im EditEngine-Modus ueber Maltes Tabulatoren einruecken
506 if( ( ImplGetOutlinerMode() == OUTLINERMODE_OUTLINEOBJECT ) ||
507 ( ImplGetOutlinerMode() == OUTLINERMODE_OUTLINEVIEW ) )
508 {
509 // Tabs raus
510 sal_uInt16 nTabs = 0;
511 while ( ( nTabs < aStr.Len() ) && ( aStr.GetChar( nTabs ) == '\t' ) )
512 nTabs++;
513 if ( nTabs )
514 aStr.Erase( 0, nTabs );
515
516 // Tiefe beibehalten ? (siehe Outliner::Insert)
517 if( !(pPara->nFlags & PARAFLAG_HOLDDEPTH) )
518 {
519 nCurDepth = nTabs-1;
520 ImplCheckDepth( nCurDepth );
521 pPara->SetDepth( nCurDepth );
522 pPara->nFlags &= (~PARAFLAG_HOLDDEPTH);
523 }
524 }
525 if( nPos ) // nicht mit dem ersten Absatz
526 {
527 pParaList->Insert( pPara, nInsPos );
528 pEditEngine->InsertParagraph( nInsPos, aStr );
529 pHdlParagraph = pPara;
530 ParagraphInsertedHdl();
531 }
532 else
533 {
534 nInsPos--;
535 pEditEngine->SetText( nInsPos, aStr );
536 }
537 ImplInitDepth( nInsPos, nCurDepth, sal_False );
538 nInsPos++;
539 nPos++;
540 }
541 }
542
543 DBG_ASSERT(pParaList->GetParagraphCount()==pEditEngine->GetParagraphCount(),"SetText failed!");
544 bFirstParaIsEmpty = sal_False;
545 ImplBlockInsertionCallbacks( sal_False );
546 pEditEngine->SetUpdateMode( bUpdate );
547 }
548
549 // pView == 0 -> Tabulatoren nicht beachten
550
ImpConvertEdtToOut(sal_uInt32 nPara,EditView * pView)551 bool Outliner::ImpConvertEdtToOut( sal_uInt32 nPara,EditView* pView)
552 {
553 DBG_CHKTHIS(Outliner,0);
554
555 bool bConverted = false;
556 sal_uInt16 nTabs = 0;
557 ESelection aDelSel;
558
559 // const SfxItemSet& rAttrs = pEditEngine->GetParaAttribs( (sal_uInt16)nPara );
560 // bool bAlreadyOutliner = rAttrs.GetItemState( EE_PARA_OUTLLRSPACE ) == SFX_ITEM_ON ? true : false;
561
562 XubString aName;
563 XubString aHeading_US( RTL_CONSTASCII_USTRINGPARAM( "heading" ) );
564 XubString aNumber_US( RTL_CONSTASCII_USTRINGPARAM( "Numbering" ) );
565
566 XubString aStr( pEditEngine->GetText( (sal_uInt16)nPara ) );
567 xub_Unicode* pPtr = (xub_Unicode*)aStr.GetBuffer();
568
569 sal_uInt16 nHeadingNumberStart = 0;
570 sal_uInt16 nNumberingNumberStart = 0;
571 SfxStyleSheet* pStyle= pEditEngine->GetStyleSheet( (sal_uInt16)nPara );
572 if( pStyle )
573 {
574 aName = pStyle->GetName();
575 sal_uInt16 nSearch;
576 if ( ( nSearch = aName.Search( aHeading_US ) ) != STRING_NOTFOUND )
577 nHeadingNumberStart = nSearch + aHeading_US.Len();
578 else if ( ( nSearch = aName.Search( aNumber_US ) ) != STRING_NOTFOUND )
579 nNumberingNumberStart = nSearch + aNumber_US.Len();
580 }
581
582 if ( nHeadingNumberStart || nNumberingNumberStart )
583 {
584 // PowerPoint-Import ?
585 if( nHeadingNumberStart && ( aStr.Len() >= 2 ) &&
586 ( pPtr[0] != '\t' ) && ( pPtr[1] == '\t' ) )
587 {
588 // Bullet & Tab raus
589 aDelSel = ESelection( (sal_uInt16)nPara, 0, (sal_uInt16)nPara, 2 );
590 }
591
592 sal_uInt16 nPos = nHeadingNumberStart ? nHeadingNumberStart : nNumberingNumberStart;
593 String aLevel = aName.Copy( nPos );
594 aLevel.EraseLeadingChars( ' ' );
595 nTabs = sal::static_int_cast< sal_uInt16 >(aLevel.ToInt32());
596 if( nTabs )
597 nTabs--; // ebene 0 = "heading 1"
598 bConverted = sal_True;
599 }
600 else
601 {
602 // Fuehrende Tabulatoren filtern
603 while( *pPtr == '\t' )
604 {
605 pPtr++;
606 nTabs++;
607 }
608 // Tabulatoren aus dem Text entfernen
609 if( nTabs )
610 aDelSel = ESelection( (sal_uInt16)nPara, 0, (sal_uInt16)nPara, nTabs );
611 }
612
613 if ( aDelSel.HasRange() )
614 {
615 if ( pView )
616 {
617 pView->SetSelection( aDelSel );
618 pView->DeleteSelected();
619 }
620 else
621 pEditEngine->QuickDelete( aDelSel );
622 }
623
624 const SfxInt16Item& rLevel = (const SfxInt16Item&) pEditEngine->GetParaAttrib( sal::static_int_cast< sal_uInt16 >(nPara), EE_PARA_OUTLLEVEL );
625 sal_Int16 nOutlLevel = rLevel.GetValue();
626
627 ImplCheckDepth( nOutlLevel );
628 ImplInitDepth( sal::static_int_cast< sal_uInt16 >(nPara), nOutlLevel, sal_False );
629
630 return bConverted;
631 }
632
SetText(const OutlinerParaObject & rPObj)633 void Outliner::SetText( const OutlinerParaObject& rPObj )
634 {
635 DBG_CHKTHIS(Outliner,0);
636
637 sal_Bool bUpdate = pEditEngine->GetUpdateMode();
638 pEditEngine->SetUpdateMode( sal_False );
639
640 sal_Bool bUndo = pEditEngine->IsUndoEnabled();
641 EnableUndo( sal_False );
642
643 Init( rPObj.GetOutlinerMode() );
644
645 ImplBlockInsertionCallbacks( sal_True );
646 pEditEngine->SetText(rPObj.GetTextObject());
647 if( rPObj.Count() != pEditEngine->GetParagraphCount() )
648 {
649 int nop=0;nop++;
650 }
651
652 bFirstParaIsEmpty = sal_False;
653
654 pParaList->Clear( sal_True );
655 for( sal_uInt16 nCurPara = 0; nCurPara < rPObj.Count(); nCurPara++ )
656 {
657 Paragraph* pPara = new Paragraph( rPObj.GetParagraphData(nCurPara));
658 ImplCheckDepth( pPara->nDepth );
659
660 pParaList->Insert( pPara, LIST_APPEND );
661 ImplCheckNumBulletItem( nCurPara );
662 }
663
664 // --> OD 2009-03-10 #i100014#
665 // It is not a good idea to substract 1 from a count and cast the result
666 // to sal_uInt16 without check, if the count is 0.
667 ImplCheckParagraphs( 0, (sal_uInt16) (pParaList->GetParagraphCount()) );
668 // <--
669
670 EnableUndo( bUndo );
671 ImplBlockInsertionCallbacks( sal_False );
672 pEditEngine->SetUpdateMode( bUpdate );
673
674 DBG_ASSERT( pParaList->GetParagraphCount()==rPObj.Count(),"SetText failed");
675 DBG_ASSERT( pEditEngine->GetParagraphCount()==rPObj.Count(),"SetText failed");
676 }
677
AddText(const OutlinerParaObject & rPObj)678 void Outliner::AddText( const OutlinerParaObject& rPObj )
679 {
680 DBG_CHKTHIS(Outliner,0);
681 Paragraph* pPara;
682
683 sal_Bool bUpdate = pEditEngine->GetUpdateMode();
684 pEditEngine->SetUpdateMode( sal_False );
685
686 ImplBlockInsertionCallbacks( sal_True );
687 sal_uLong nPara;
688 if( bFirstParaIsEmpty )
689 {
690 pParaList->Clear( sal_True );
691 pEditEngine->SetText(rPObj.GetTextObject());
692 nPara = 0;
693 }
694 else
695 {
696 nPara = pParaList->GetParagraphCount();
697 pEditEngine->InsertParagraph( EE_PARA_APPEND, rPObj.GetTextObject() );
698 }
699 bFirstParaIsEmpty = sal_False;
700
701 for( sal_uInt16 n = 0; n < rPObj.Count(); n++ )
702 {
703 pPara = new Paragraph( rPObj.GetParagraphData(n) );
704 pParaList->Insert( pPara, LIST_APPEND );
705 sal_uInt16 nP = sal::static_int_cast< sal_uInt16 >(nPara+n);
706 DBG_ASSERT(pParaList->GetAbsPos(pPara)==nP,"AddText:Out of sync");
707 ImplInitDepth( nP, pPara->GetDepth(), sal_False );
708 }
709 DBG_ASSERT( pEditEngine->GetParagraphCount()==pParaList->GetParagraphCount(), "SetText: OutOfSync" );
710
711 // --> OD 2009-03-10 #i100014#
712 // It is not a good idea to substract 1 from a count and cast the result
713 // to sal_uInt16 without check, if the count is 0.
714 ImplCheckParagraphs( (sal_uInt16)nPara, (sal_uInt16) (pParaList->GetParagraphCount()) );
715 // <--
716
717 ImplBlockInsertionCallbacks( sal_False );
718 pEditEngine->SetUpdateMode( bUpdate );
719 }
720
FieldClicked(const SvxFieldItem & rField,sal_uInt16 nPara,sal_uInt16 nPos)721 void __EXPORT Outliner::FieldClicked( const SvxFieldItem& rField, sal_uInt16 nPara, sal_uInt16 nPos )
722 {
723 DBG_CHKTHIS(Outliner,0);
724
725 if ( aFieldClickedHdl.IsSet() )
726 {
727 EditFieldInfo aFldInfo( this, rField, nPara, nPos );
728 aFldInfo.SetSimpleClick( sal_True );
729 aFieldClickedHdl.Call( &aFldInfo );
730 }
731 }
732
733
FieldSelected(const SvxFieldItem & rField,sal_uInt16 nPara,sal_uInt16 nPos)734 void __EXPORT Outliner::FieldSelected( const SvxFieldItem& rField, sal_uInt16 nPara, sal_uInt16 nPos )
735 {
736 DBG_CHKTHIS(Outliner,0);
737 if ( !aFieldClickedHdl.IsSet() )
738 return;
739
740 EditFieldInfo aFldInfo( this, rField, nPara, nPos );
741 aFldInfo.SetSimpleClick( sal_False );
742 aFieldClickedHdl.Call( &aFldInfo );
743 }
744
745
CalcFieldValue(const SvxFieldItem & rField,sal_uInt16 nPara,sal_uInt16 nPos,Color * & rpTxtColor,Color * & rpFldColor)746 XubString __EXPORT Outliner::CalcFieldValue( const SvxFieldItem& rField, sal_uInt16 nPara, sal_uInt16 nPos, Color*& rpTxtColor, Color*& rpFldColor )
747 {
748 DBG_CHKTHIS(Outliner,0);
749 if ( !aCalcFieldValueHdl.IsSet() )
750 return String( ' ' );
751
752 EditFieldInfo aFldInfo( this, rField, nPara, nPos );
753 // Die FldColor ist mit COL_LIGHTGRAY voreingestellt.
754 if ( rpFldColor )
755 aFldInfo.SetFldColor( *rpFldColor );
756
757 aCalcFieldValueHdl.Call( &aFldInfo );
758 if ( aFldInfo.GetTxtColor() )
759 {
760 delete rpTxtColor;
761 rpTxtColor = new Color( *aFldInfo.GetTxtColor() );
762 }
763
764 delete rpFldColor;
765 rpFldColor = aFldInfo.GetFldColor() ? new Color( *aFldInfo.GetFldColor() ) : 0;
766
767 return aFldInfo.GetRepresentation();
768 }
769
SetStyleSheet(sal_uLong nPara,SfxStyleSheet * pStyle)770 void Outliner::SetStyleSheet( sal_uLong nPara, SfxStyleSheet* pStyle )
771 {
772 DBG_CHKTHIS(Outliner,0);
773 Paragraph* pPara = pParaList->GetParagraph( nPara );
774 if (pPara)
775 {
776 pEditEngine->SetStyleSheet( (sal_uInt16)nPara, pStyle );
777 pPara->nFlags |= PARAFLAG_SETBULLETTEXT;
778 ImplCheckNumBulletItem( (sal_uInt16) nPara );
779 }
780 }
781
SetVisible(Paragraph * pPara,sal_Bool bVisible)782 void Outliner::SetVisible( Paragraph* pPara, sal_Bool bVisible )
783 {
784 DBG_CHKTHIS(Outliner,0);
785 DBG_ASSERT( pPara, "SetVisible: pPara = NULL" );
786
787 if (pPara)
788 {
789 pPara->bVisible = bVisible;
790 sal_uLong nPara = pParaList->GetAbsPos( pPara );
791 pEditEngine->ShowParagraph( (sal_uInt16)nPara, bVisible );
792 }
793 }
794
ImplCheckNumBulletItem(sal_uInt16 nPara)795 void Outliner::ImplCheckNumBulletItem( sal_uInt16 nPara )
796 {
797 Paragraph* pPara = pParaList->GetParagraph( nPara );
798 if (pPara)
799 pPara->aBulSize.Width() = -1;
800 }
801
ImplSetLevelDependendStyleSheet(sal_uInt16 nPara,SfxStyleSheet * pLevelStyle)802 void Outliner::ImplSetLevelDependendStyleSheet( sal_uInt16 nPara, SfxStyleSheet* pLevelStyle )
803 {
804 DBG_CHKTHIS(Outliner,0);
805
806 DBG_ASSERT( ( ImplGetOutlinerMode() == OUTLINERMODE_OUTLINEOBJECT ) || ( ImplGetOutlinerMode() == OUTLINERMODE_OUTLINEVIEW ), "SetLevelDependendStyleSheet: Wrong Mode!" );
807
808 SfxStyleSheet* pStyle = pLevelStyle;
809 if ( !pStyle )
810 pStyle = GetStyleSheet( nPara );
811
812 if ( pStyle )
813 {
814 sal_Int16 nDepth = GetDepth( nPara );
815 if( nDepth < 0 )
816 nDepth = 0;
817
818 String aNewStyleSheetName( pStyle->GetName() );
819 aNewStyleSheetName.Erase( aNewStyleSheetName.Len()-1, 1 );
820 aNewStyleSheetName += String::CreateFromInt32( nDepth+1 );
821 SfxStyleSheet* pNewStyle = (SfxStyleSheet*)GetStyleSheetPool()->Find( aNewStyleSheetName, pStyle->GetFamily() );
822 DBG_ASSERT( pNewStyle, "AutoStyleSheetName - Style not found!" );
823 if ( pNewStyle && ( pNewStyle != GetStyleSheet( nPara ) ) )
824 {
825 SfxItemSet aOldAttrs( GetParaAttribs( nPara ) );
826 SetStyleSheet( nPara, pNewStyle );
827 if ( aOldAttrs.GetItemState( EE_PARA_NUMBULLET ) == SFX_ITEM_ON )
828 {
829 SfxItemSet aAttrs( GetParaAttribs( nPara ) );
830 aAttrs.Put( aOldAttrs.Get( EE_PARA_NUMBULLET ) );
831 SetParaAttribs( nPara, aAttrs );
832 }
833 }
834 }
835 }
836
ImplInitDepth(sal_uInt16 nPara,sal_Int16 nDepth,sal_Bool bCreateUndo,sal_Bool bUndoAction)837 void Outliner::ImplInitDepth( sal_uInt16 nPara, sal_Int16 nDepth, sal_Bool bCreateUndo, sal_Bool bUndoAction )
838 {
839 DBG_CHKTHIS(Outliner,0);
840
841 DBG_ASSERT( ( nDepth >= nMinDepth ) && ( nDepth <= nMaxDepth ), "ImplInitDepth - Depth is invalid!" );
842
843 Paragraph* pPara = pParaList->GetParagraph( nPara );
844 if (!pPara)
845 return;
846 sal_Int16 nOldDepth = pPara->GetDepth();
847 pPara->SetDepth( nDepth );
848
849 // Bei IsInUndo brauchen Attribute und Style nicht eingestellt werden,
850 // dort werden die alten Werte durch die EditEngine restauriert.
851
852 if( !IsInUndo() )
853 {
854 sal_Bool bUpdate = pEditEngine->GetUpdateMode();
855 pEditEngine->SetUpdateMode( sal_False );
856
857 sal_Bool bUndo = bCreateUndo && IsUndoEnabled();
858 if ( bUndo && bUndoAction )
859 UndoActionStart( OLUNDO_DEPTH );
860
861 SfxItemSet aAttrs( pEditEngine->GetParaAttribs( nPara ) );
862 aAttrs.Put( SfxInt16Item( EE_PARA_OUTLLEVEL, nDepth ) );
863 pEditEngine->SetParaAttribs( nPara, aAttrs );
864 ImplCheckNumBulletItem( nPara );
865 ImplCalcBulletText( nPara, sal_False, sal_False );
866
867 if ( bUndo )
868 {
869 InsertUndo( new OutlinerUndoChangeDepth( this, nPara, nOldDepth, nDepth ) );
870 if ( bUndoAction )
871 UndoActionEnd( OLUNDO_DEPTH );
872 }
873
874 pEditEngine->SetUpdateMode( bUpdate );
875 }
876 }
877
SetParaAttribs(sal_uInt16 nPara,const SfxItemSet & rSet)878 void Outliner::SetParaAttribs( sal_uInt16 nPara, const SfxItemSet& rSet )
879 {
880 DBG_CHKTHIS(Outliner,0);
881
882 pEditEngine->SetParaAttribs( nPara, rSet );
883 }
884
Expand(Paragraph * pPara)885 sal_Bool Outliner::Expand( Paragraph* pPara )
886 {
887 DBG_CHKTHIS(Outliner,0);
888
889 if ( pParaList->HasHiddenChilds( pPara ) )
890 {
891 OLUndoExpand* pUndo = 0;
892 sal_Bool bUndo = IsUndoEnabled() && !IsInUndo();
893 if( bUndo )
894 {
895 UndoActionStart( OLUNDO_EXPAND );
896 pUndo = new OLUndoExpand( this, OLUNDO_EXPAND );
897 pUndo->pParas = 0;
898 pUndo->nCount = (sal_uInt16)pParaList->GetAbsPos( pPara );
899 }
900 pHdlParagraph = pPara;
901 bIsExpanding = sal_True;
902 pParaList->Expand( pPara );
903 ExpandHdl();
904 InvalidateBullet( pPara, pParaList->GetAbsPos(pPara) );
905 if( bUndo )
906 {
907 InsertUndo( pUndo );
908 UndoActionEnd( OLUNDO_EXPAND );
909 }
910 return sal_True;
911 }
912 return sal_False;
913 }
914
915
Collapse(Paragraph * pPara)916 sal_Bool Outliner::Collapse( Paragraph* pPara )
917 {
918 DBG_CHKTHIS(Outliner,0);
919 if ( pParaList->HasVisibleChilds( pPara ) ) // expandiert
920 {
921 OLUndoExpand* pUndo = 0;
922 sal_Bool bUndo = sal_False;
923
924 if( !IsInUndo() && IsUndoEnabled() )
925 bUndo = sal_True;
926 if( bUndo )
927 {
928 UndoActionStart( OLUNDO_COLLAPSE );
929 pUndo = new OLUndoExpand( this, OLUNDO_COLLAPSE );
930 pUndo->pParas = 0;
931 pUndo->nCount = (sal_uInt16)pParaList->GetAbsPos( pPara );
932 }
933
934 pHdlParagraph = pPara;
935 bIsExpanding = sal_False;
936 pParaList->Collapse( pPara );
937 ExpandHdl();
938 InvalidateBullet( pPara, pParaList->GetAbsPos(pPara) );
939 if( bUndo )
940 {
941 InsertUndo( pUndo );
942 UndoActionEnd( OLUNDO_COLLAPSE );
943 }
944 return sal_True;
945 }
946 return sal_False;
947 }
948
949
ImpCalcBulletFont(sal_uInt16 nPara) const950 Font Outliner::ImpCalcBulletFont( sal_uInt16 nPara ) const
951 {
952 const SvxNumberFormat* pFmt = GetNumberFormat( nPara );
953 DBG_ASSERT( pFmt && ( pFmt->GetNumberingType() != SVX_NUM_BITMAP ) && ( pFmt->GetNumberingType() != SVX_NUM_NUMBER_NONE ), "ImpCalcBulletFont: Missing or BitmapBullet!" );
954
955 Font aStdFont; //#107508#
956 if ( !pEditEngine->IsFlatMode() )
957 {
958 ESelection aSel( nPara, 0, nPara, 0 );
959 aStdFont = EditEngine::CreateFontFromItemSet( pEditEngine->GetAttribs( aSel ), GetScriptType( aSel ) );
960 }
961 else
962 {
963 aStdFont = pEditEngine->GetStandardFont( nPara );
964 }
965
966 Font aBulletFont;
967 if ( pFmt->GetNumberingType() == SVX_NUM_CHAR_SPECIAL )
968 {
969 aBulletFont = *pFmt->GetBulletFont();
970 }
971 else
972 {
973 aBulletFont = aStdFont;
974 aBulletFont.SetUnderline( UNDERLINE_NONE );
975 aBulletFont.SetOverline( UNDERLINE_NONE );
976 aBulletFont.SetStrikeout( STRIKEOUT_NONE );
977 aBulletFont.SetEmphasisMark( EMPHASISMARK_NONE );
978 aBulletFont.SetRelief( RELIEF_NONE );
979 }
980
981 // #107508# Use original scale...
982 sal_uInt16 nScale = /* pEditEngine->IsFlatMode() ? DEFAULT_SCALE : */ pFmt->GetBulletRelSize();
983 sal_uLong nScaledLineHeight = aStdFont.GetSize().Height();
984 nScaledLineHeight *= nScale*10;
985 nScaledLineHeight /= 1000;
986
987 aBulletFont.SetAlign( ALIGN_BOTTOM );
988 aBulletFont.SetSize( Size( 0, nScaledLineHeight ) );
989 sal_Bool bVertical = IsVertical();
990 aBulletFont.SetVertical( bVertical );
991 aBulletFont.SetOrientation( bVertical ? 2700 : 0 );
992
993 Color aColor( COL_AUTO );
994 if( !pEditEngine->IsFlatMode() && !( pEditEngine->GetControlWord() & EE_CNTRL_NOCOLORS ) )
995 {
996 aColor = pFmt->GetBulletColor();
997 }
998
999 if ( ( aColor == COL_AUTO ) || ( IsForceAutoColor() ) )
1000 aColor = pEditEngine->GetAutoColor();
1001
1002 aBulletFont.SetColor( aColor );
1003 return aBulletFont;
1004 }
1005
PaintBullet(sal_uInt16 nPara,const Point & rStartPos,const Point & rOrigin,short nOrientation,OutputDevice * pOutDev)1006 void Outliner::PaintBullet( sal_uInt16 nPara, const Point& rStartPos,
1007 const Point& rOrigin, short nOrientation, OutputDevice* pOutDev )
1008 {
1009 DBG_CHKTHIS(Outliner,0);
1010
1011 bool bDrawBullet = false;
1012 if (pEditEngine)
1013 {
1014 const SfxBoolItem& rBulletState = (const SfxBoolItem&) pEditEngine->GetParaAttrib( nPara, EE_PARA_BULLETSTATE );
1015 bDrawBullet = rBulletState.GetValue() ? true : false;
1016 }
1017
1018 if ( ImplHasNumberFormat( nPara ) && bDrawBullet)
1019 {
1020 sal_Bool bVertical = IsVertical();
1021
1022 sal_Bool bRightToLeftPara = pEditEngine->IsRightToLeft( nPara );
1023
1024 Rectangle aBulletArea( ImpCalcBulletArea( nPara, sal_True, sal_False ) );
1025
1026 Paragraph* pPara = pParaList->GetParagraph( nPara );
1027 const SvxNumberFormat* pFmt = GetNumberFormat( nPara );
1028 if ( pFmt && ( pFmt->GetNumberingType() != SVX_NUM_NUMBER_NONE ) )
1029 {
1030 if( pFmt->GetNumberingType() != SVX_NUM_BITMAP )
1031 {
1032 Font aBulletFont( ImpCalcBulletFont( nPara ) );
1033 // #2338# Use base line
1034 sal_Bool bSymbol = pFmt->GetNumberingType() == SVX_NUM_CHAR_SPECIAL;
1035 aBulletFont.SetAlign( bSymbol ? ALIGN_BOTTOM : ALIGN_BASELINE );
1036 Font aOldFont = pOutDev->GetFont();
1037 pOutDev->SetFont( aBulletFont );
1038
1039 ParagraphInfos aParaInfos = pEditEngine->GetParagraphInfos( nPara );
1040 Point aTextPos;
1041 if ( !bVertical )
1042 {
1043 // aTextPos.Y() = rStartPos.Y() + aBulletArea.Bottom();
1044 aTextPos.Y() = rStartPos.Y() + ( bSymbol ? aBulletArea.Bottom() : aParaInfos.nFirstLineMaxAscent );
1045 if ( !bRightToLeftPara )
1046 aTextPos.X() = rStartPos.X() + aBulletArea.Left();
1047 else
1048 aTextPos.X() = rStartPos.X() + GetPaperSize().Width() - aBulletArea.Left();
1049 }
1050 else
1051 {
1052 // aTextPos.X() = rStartPos.X() - aBulletArea.Bottom();
1053 aTextPos.X() = rStartPos.X() - ( bSymbol ? aBulletArea.Bottom() : aParaInfos.nFirstLineMaxAscent );
1054 aTextPos.Y() = rStartPos.Y() + aBulletArea.Left();
1055 }
1056
1057 if ( nOrientation )
1058 {
1059 // Sowohl TopLeft als auch BottomLeft nicht ganz richtig, da
1060 // in EditEngine BaseLine...
1061 double nRealOrientation = nOrientation*F_PI1800;
1062 double nCos = cos( nRealOrientation );
1063 double nSin = sin( nRealOrientation );
1064 Point aRotatedPos;
1065 // Translation...
1066 aTextPos -= rOrigin;
1067 // Rotation...
1068 aRotatedPos.X()=(long) (nCos*aTextPos.X() + nSin*aTextPos.Y());
1069 aRotatedPos.Y()=(long) - (nSin*aTextPos.X() - nCos*aTextPos.Y());
1070 aTextPos = aRotatedPos;
1071 // Translation...
1072 aTextPos += rOrigin;
1073 Font aRotatedFont( aBulletFont );
1074 aRotatedFont.SetOrientation( nOrientation );
1075 pOutDev->SetFont( aRotatedFont );
1076 }
1077
1078 // #105803# VCL will care for brackets and so on...
1079 sal_uLong nLayoutMode = pOutDev->GetLayoutMode();
1080 nLayoutMode &= ~(TEXT_LAYOUT_BIDI_RTL|TEXT_LAYOUT_COMPLEX_DISABLED|TEXT_LAYOUT_BIDI_STRONG);
1081 if ( bRightToLeftPara )
1082 nLayoutMode |= TEXT_LAYOUT_BIDI_RTL;
1083 pOutDev->SetLayoutMode( nLayoutMode );
1084
1085 if(bStrippingPortions)
1086 {
1087 const Font aSvxFont(pOutDev->GetFont());
1088 sal_Int32* pBuf = new sal_Int32[ pPara->GetText().Len() ];
1089 pOutDev->GetTextArray( pPara->GetText(), pBuf );
1090
1091 if(bSymbol)
1092 {
1093 // aTextPos is Bottom, go to Baseline
1094 FontMetric aMetric(pOutDev->GetFontMetric());
1095 aTextPos.Y() -= aMetric.GetDescent();
1096 }
1097
1098 DrawingText(aTextPos, pPara->GetText(), 0, pPara->GetText().Len(), pBuf,
1099 aSvxFont, nPara, 0xFFFF, 0xFF, 0, 0, false, false, true, 0, Color(), Color());
1100
1101 delete[] pBuf;
1102 }
1103 else
1104 {
1105 pOutDev->DrawText( aTextPos, pPara->GetText() );
1106 }
1107
1108 pOutDev->SetFont( aOldFont );
1109 }
1110 else
1111 {
1112 if ( pFmt->GetBrush()->GetGraphicObject() )
1113 {
1114 Point aBulletPos;
1115 if ( !bVertical )
1116 {
1117 aBulletPos.Y() = rStartPos.Y() + aBulletArea.Top();
1118 if ( !bRightToLeftPara )
1119 aBulletPos.X() = rStartPos.X() + aBulletArea.Left();
1120 else
1121 aBulletPos.X() = rStartPos.X() + GetPaperSize().Width() - aBulletArea.Right();
1122 }
1123 else
1124 {
1125 aBulletPos.X() = rStartPos.X() - aBulletArea.Bottom();
1126 aBulletPos.Y() = rStartPos.Y() + aBulletArea.Left();
1127 }
1128
1129 if(bStrippingPortions)
1130 {
1131 if(aDrawBulletHdl.IsSet())
1132 {
1133 // call something analog to aDrawPortionHdl (if set) and feed it something
1134 // analog to DrawPortionInfo...
1135 // created aDrawBulletHdl, Set/GetDrawBulletHdl.
1136 // created DrawBulletInfo and added handling to sdrtextdecomposition.cxx
1137 DrawBulletInfo aDrawBulletInfo(
1138 *pFmt->GetBrush()->GetGraphicObject(),
1139 aBulletPos,
1140 pPara->aBulSize);
1141
1142 aDrawBulletHdl.Call(&aDrawBulletInfo);
1143 }
1144 }
1145 else
1146 {
1147 // MT: Remove CAST when KA made the Draw-Method const
1148 ((GraphicObject*)pFmt->GetBrush()->GetGraphicObject())->Draw( pOutDev, aBulletPos, pPara->aBulSize );
1149 }
1150 }
1151 }
1152 }
1153
1154 // Bei zusammengeklappten Absaetzen einen Strich vor den Text malen.
1155 if( pParaList->HasChilds(pPara) && !pParaList->HasVisibleChilds(pPara) &&
1156 !bStrippingPortions && !nOrientation )
1157 {
1158 long nWidth = pOutDev->PixelToLogic( Size( 10, 0 ) ).Width();
1159
1160 Point aStartPos, aEndPos;
1161 if ( !bVertical )
1162 {
1163 aStartPos.Y() = rStartPos.Y() + aBulletArea.Bottom();
1164 if ( !bRightToLeftPara )
1165 aStartPos.X() = rStartPos.X() + aBulletArea.Right();
1166 else
1167 aStartPos.X() = rStartPos.X() + GetPaperSize().Width() - aBulletArea.Left();
1168 aEndPos = aStartPos;
1169 aEndPos.X() += nWidth;
1170 }
1171 else
1172 {
1173 aStartPos.X() = rStartPos.X() - aBulletArea.Bottom();
1174 aStartPos.Y() = rStartPos.Y() + aBulletArea.Right();
1175 aEndPos = aStartPos;
1176 aEndPos.Y() += nWidth;
1177 }
1178
1179 const Color& rOldLineColor = pOutDev->GetLineColor();
1180 pOutDev->SetLineColor( Color( COL_BLACK ) );
1181 pOutDev->DrawLine( aStartPos, aEndPos );
1182 pOutDev->SetLineColor( rOldLineColor );
1183 }
1184 }
1185 }
1186
InvalidateBullet(Paragraph *,sal_uLong nPara)1187 void Outliner::InvalidateBullet( Paragraph* /*pPara*/, sal_uLong nPara )
1188 {
1189 DBG_CHKTHIS(Outliner,0);
1190
1191 long nLineHeight = (long)pEditEngine->GetLineHeight((sal_uInt16)nPara );
1192 OutlinerView* pView = aViewList.First();
1193 while( pView )
1194 {
1195 Point aPos( pView->pEditView->GetWindowPosTopLeft((sal_uInt16)nPara ) );
1196 Rectangle aRect( pView->GetOutputArea() );
1197 aRect.Right() = aPos.X();
1198 aRect.Top() = aPos.Y();
1199 aRect.Bottom() = aPos.Y();
1200 aRect.Bottom() += nLineHeight;
1201
1202 pView->GetWindow()->Invalidate( aRect );
1203 pView = aViewList.Next();
1204 }
1205 }
1206
Read(SvStream & rInput,const String & rBaseURL,sal_uInt16 eFormat,SvKeyValueIterator * pHTTPHeaderAttrs)1207 sal_uLong Outliner::Read( SvStream& rInput, const String& rBaseURL, sal_uInt16 eFormat, SvKeyValueIterator* pHTTPHeaderAttrs )
1208 {
1209 DBG_CHKTHIS(Outliner,0);
1210
1211 sal_Bool bOldUndo = pEditEngine->IsUndoEnabled();
1212 EnableUndo( sal_False );
1213
1214 sal_Bool bUpdate = pEditEngine->GetUpdateMode();
1215 pEditEngine->SetUpdateMode( sal_False );
1216
1217 Clear();
1218
1219 ImplBlockInsertionCallbacks( sal_True );
1220 sal_uLong nRet = pEditEngine->Read( rInput, rBaseURL, (EETextFormat)eFormat, pHTTPHeaderAttrs );
1221
1222 bFirstParaIsEmpty = sal_False;
1223
1224 sal_uInt16 nParas = pEditEngine->GetParagraphCount();
1225 pParaList->Clear( sal_True );
1226 sal_uInt16 n;
1227 for ( n = 0; n < nParas; n++ )
1228 {
1229 Paragraph* pPara = new Paragraph( 0 );
1230 pParaList->Insert( pPara, LIST_APPEND );
1231
1232 if ( eFormat == EE_FORMAT_BIN )
1233 {
1234 const SfxItemSet& rAttrs = pEditEngine->GetParaAttribs( n );
1235 const SfxInt16Item& rLevel = (const SfxInt16Item&) rAttrs.Get( EE_PARA_OUTLLEVEL );
1236 sal_Int16 nDepth = rLevel.GetValue();
1237 ImplInitDepth( n, nDepth, sal_False );
1238 }
1239 }
1240
1241 if ( eFormat != EE_FORMAT_BIN )
1242 {
1243 ImpFilterIndents( 0, nParas-1 );
1244 }
1245
1246 ImplBlockInsertionCallbacks( sal_False );
1247 pEditEngine->SetUpdateMode( bUpdate );
1248 EnableUndo( bOldUndo );
1249
1250 return nRet;
1251 }
1252
1253
ImpFilterIndents(sal_uLong nFirstPara,sal_uLong nLastPara)1254 void Outliner::ImpFilterIndents( sal_uLong nFirstPara, sal_uLong nLastPara )
1255 {
1256 DBG_CHKTHIS(Outliner,0);
1257
1258 sal_Bool bUpdate = pEditEngine->GetUpdateMode();
1259 pEditEngine->SetUpdateMode( sal_False );
1260
1261 Paragraph* pLastConverted = NULL;
1262 for( sal_uLong nPara = nFirstPara; nPara <= nLastPara; nPara++ )
1263 {
1264 Paragraph* pPara = pParaList->GetParagraph( nPara );
1265 if (pPara)
1266 {
1267 if( ImpConvertEdtToOut( nPara ) )
1268 {
1269 pLastConverted = pPara;
1270 }
1271 else if ( pLastConverted )
1272 {
1273 // Normale Absaetze unter der Ueberschrift anordnen...
1274 pPara->SetDepth( pLastConverted->GetDepth() );
1275 }
1276
1277 ImplInitDepth( (sal_uInt16)nPara, pPara->GetDepth(), sal_False );
1278 }
1279 }
1280
1281 pEditEngine->SetUpdateMode( bUpdate );
1282 }
1283
GetUndoManager()1284 ::svl::IUndoManager& Outliner::GetUndoManager()
1285 {
1286 DBG_CHKTHIS(Outliner,0);
1287 return pEditEngine->GetUndoManager();
1288 }
1289
SetUndoManager(::svl::IUndoManager * pNew)1290 ::svl::IUndoManager* Outliner::SetUndoManager(::svl::IUndoManager* pNew)
1291 {
1292 DBG_CHKTHIS(Outliner,0);
1293 return pEditEngine->SetUndoManager(pNew);
1294 }
1295
ImpTextPasted(sal_uLong nStartPara,sal_uInt16 nCount)1296 void Outliner::ImpTextPasted( sal_uLong nStartPara, sal_uInt16 nCount )
1297 {
1298 DBG_CHKTHIS(Outliner,0);
1299
1300 sal_Bool bUpdate = pEditEngine->GetUpdateMode();
1301 pEditEngine->SetUpdateMode( sal_False );
1302
1303 const sal_uLong nStart = nStartPara;
1304
1305 Paragraph* pPara = pParaList->GetParagraph( nStartPara );
1306 // Paragraph* pLastConverted = NULL;
1307 // bool bFirst = true;
1308
1309 while( nCount && pPara )
1310 {
1311 if( ImplGetOutlinerMode() != OUTLINERMODE_TEXTOBJECT )
1312 {
1313 nDepthChangedHdlPrevDepth = pPara->GetDepth();
1314 mnDepthChangeHdlPrevFlags = pPara->nFlags;
1315
1316 ImpConvertEdtToOut( nStartPara );
1317
1318 pHdlParagraph = pPara;
1319
1320 if( nStartPara == nStart )
1321 {
1322 // the existing paragraph has changed depth or flags
1323 if( (pPara->GetDepth() != nDepthChangedHdlPrevDepth) || (pPara->nFlags != mnDepthChangeHdlPrevFlags) )
1324 DepthChangedHdl();
1325 }
1326 }
1327 else // EditEngine-Modus
1328 {
1329 sal_Int16 nDepth = -1;
1330 const SfxItemSet& rAttrs = pEditEngine->GetParaAttribs( (sal_uInt16)nStartPara );
1331 if ( rAttrs.GetItemState( EE_PARA_OUTLLEVEL ) == SFX_ITEM_ON )
1332 {
1333 const SfxInt16Item& rLevel = (const SfxInt16Item&) rAttrs.Get( EE_PARA_OUTLLEVEL );
1334 nDepth = rLevel.GetValue();
1335 }
1336 if ( nDepth != GetDepth( nStartPara ) )
1337 ImplInitDepth( (sal_uInt16)nStartPara, nDepth, sal_False );
1338 }
1339
1340 nCount--;
1341 nStartPara++;
1342 pPara = pParaList->GetParagraph( nStartPara );
1343 }
1344
1345 pEditEngine->SetUpdateMode( bUpdate );
1346
1347 DBG_ASSERT(pParaList->GetParagraphCount()==pEditEngine->GetParagraphCount(),"ImpTextPasted failed");
1348 }
1349
IndentingPagesHdl(OutlinerView * pView)1350 long Outliner::IndentingPagesHdl( OutlinerView* pView )
1351 {
1352 DBG_CHKTHIS(Outliner,0);
1353 if( !aIndentingPagesHdl.IsSet() )
1354 return 1;
1355 return aIndentingPagesHdl.Call( pView );
1356 }
1357
ImpCanIndentSelectedPages(OutlinerView * pCurView)1358 sal_Bool Outliner::ImpCanIndentSelectedPages( OutlinerView* pCurView )
1359 {
1360 DBG_CHKTHIS(Outliner,0);
1361 // Die selektierten Seiten muessen vorher durch ImpCalcSelectedPages
1362 // schon eingestellt sein
1363
1364 // Wenn der erste Absatz auf Ebene 0 liegt darf er auf keinen Fall
1365 // eingerueckt werden, evtl folgen aber weitere auf Ebene 0.
1366 if ( ( mnFirstSelPage == 0 ) && ( ImplGetOutlinerMode() != OUTLINERMODE_TEXTOBJECT ) )
1367 {
1368 if ( nDepthChangedHdlPrevDepth == 1 ) // ist die einzige Seite
1369 return sal_False;
1370 else
1371 pCurView->ImpCalcSelectedPages( sal_False ); // ohne die erste
1372 }
1373 return (sal_Bool)IndentingPagesHdl( pCurView );
1374 }
1375
1376
ImpCanDeleteSelectedPages(OutlinerView * pCurView)1377 sal_Bool Outliner::ImpCanDeleteSelectedPages( OutlinerView* pCurView )
1378 {
1379 DBG_CHKTHIS(Outliner,0);
1380 // Die selektierten Seiten muessen vorher durch ImpCalcSelectedPages
1381 // schon eingestellt sein
1382 return (sal_Bool)RemovingPagesHdl( pCurView );
1383 }
1384
Outliner(SfxItemPool * pPool,sal_uInt16 nMode)1385 Outliner::Outliner( SfxItemPool* pPool, sal_uInt16 nMode )
1386 : nMinDepth( -1 )
1387 {
1388 DBG_CTOR( Outliner, 0 );
1389
1390 bStrippingPortions = sal_False;
1391 bPasting = sal_False;
1392
1393 nFirstPage = 1;
1394 bBlockInsCallback = sal_False;
1395
1396 nMaxDepth = 9;
1397
1398 pParaList = new ParagraphList;
1399 pParaList->SetVisibleStateChangedHdl( LINK( this, Outliner, ParaVisibleStateChangedHdl ) );
1400 Paragraph* pPara = new Paragraph( 0 );
1401 pParaList->Insert( pPara, LIST_APPEND );
1402 bFirstParaIsEmpty = sal_True;
1403
1404 pEditEngine = new OutlinerEditEng( this, pPool );
1405 pEditEngine->SetBeginMovingParagraphsHdl( LINK( this, Outliner, BeginMovingParagraphsHdl ) );
1406 pEditEngine->SetEndMovingParagraphsHdl( LINK( this, Outliner, EndMovingParagraphsHdl ) );
1407 pEditEngine->SetBeginPasteOrDropHdl( LINK( this, Outliner, BeginPasteOrDropHdl ) );
1408 pEditEngine->SetEndPasteOrDropHdl( LINK( this, Outliner, EndPasteOrDropHdl ) );
1409
1410 Init( nMode );
1411 }
1412
~Outliner()1413 Outliner::~Outliner()
1414 {
1415 DBG_DTOR(Outliner,0);
1416
1417 pParaList->Clear( sal_True );
1418 delete pParaList;
1419 delete pEditEngine;
1420 }
1421
InsertView(OutlinerView * pView,sal_uLong nIndex)1422 sal_uLong Outliner::InsertView( OutlinerView* pView, sal_uLong nIndex )
1423 {
1424 DBG_CHKTHIS(Outliner,0);
1425
1426 aViewList.Insert( pView, nIndex );
1427 pEditEngine->InsertView( pView->pEditView, (sal_uInt16)nIndex );
1428 return aViewList.GetPos( pView );
1429 }
1430
RemoveView(OutlinerView * pView)1431 OutlinerView* Outliner::RemoveView( OutlinerView* pView )
1432 {
1433 DBG_CHKTHIS(Outliner,0);
1434
1435 sal_uLong nPos = aViewList.GetPos( pView );
1436 if ( nPos != LIST_ENTRY_NOTFOUND )
1437 {
1438 pView->pEditView->HideCursor(); // HACK wg. BugId 10006
1439 pEditEngine->RemoveView( pView->pEditView );
1440 aViewList.Remove( nPos );
1441 }
1442 return NULL; // MT: return ueberfluessig
1443 }
1444
RemoveView(sal_uLong nIndex)1445 OutlinerView* Outliner::RemoveView( sal_uLong nIndex )
1446 {
1447 DBG_CHKTHIS(Outliner,0);
1448
1449 EditView* pEditView = pEditEngine->GetView( (sal_uInt16)nIndex );
1450 pEditView->HideCursor(); // HACK wg. BugId 10006
1451
1452 pEditEngine->RemoveView( (sal_uInt16)nIndex );
1453 aViewList.Remove( nIndex );
1454 return NULL; // MT: return ueberfluessig
1455 }
1456
1457
GetView(sal_uLong nIndex) const1458 OutlinerView* Outliner::GetView( sal_uLong nIndex ) const
1459 {
1460 DBG_CHKTHIS(Outliner,0);
1461 return aViewList.GetObject( nIndex );
1462 }
1463
GetViewCount() const1464 sal_uLong Outliner::GetViewCount() const
1465 {
1466 DBG_CHKTHIS(Outliner,0);
1467 return aViewList.Count();
1468 }
1469
ParagraphInsertedHdl()1470 void Outliner::ParagraphInsertedHdl()
1471 {
1472 DBG_CHKTHIS(Outliner,0);
1473 if( !IsInUndo() )
1474 aParaInsertedHdl.Call( this );
1475 }
1476
1477
ParagraphRemovingHdl()1478 void Outliner::ParagraphRemovingHdl()
1479 {
1480 DBG_CHKTHIS(Outliner,0);
1481 if( !IsInUndo() )
1482 aParaRemovingHdl.Call( this );
1483 }
1484
1485
DepthChangedHdl()1486 void Outliner::DepthChangedHdl()
1487 {
1488 DBG_CHKTHIS(Outliner,0);
1489 if( !IsInUndo() )
1490 aDepthChangedHdl.Call( this );
1491 }
1492
1493
GetAbsPos(Paragraph * pPara)1494 sal_uLong Outliner::GetAbsPos( Paragraph* pPara )
1495 {
1496 DBG_CHKTHIS(Outliner,0);
1497 DBG_ASSERT(pPara,"GetAbsPos:No Para");
1498 return pParaList->GetAbsPos( pPara );
1499 }
1500
GetParagraphCount() const1501 sal_uLong Outliner::GetParagraphCount() const
1502 {
1503 DBG_CHKTHIS(Outliner,0);
1504 return pParaList->GetParagraphCount();
1505 }
1506
GetParagraph(sal_uLong nAbsPos) const1507 Paragraph* Outliner::GetParagraph( sal_uLong nAbsPos ) const
1508 {
1509 DBG_CHKTHIS(Outliner,0);
1510 return pParaList->GetParagraph( nAbsPos );
1511 }
1512
HasChilds(Paragraph * pParagraph) const1513 sal_Bool Outliner::HasChilds( Paragraph* pParagraph ) const
1514 {
1515 DBG_CHKTHIS(Outliner,0);
1516 return pParaList->HasChilds( pParagraph );
1517 }
1518
ImplHasNumberFormat(sal_uInt16 nPara) const1519 bool Outliner::ImplHasNumberFormat( sal_uInt16 nPara ) const
1520 {
1521 return GetNumberFormat(nPara) != 0;
1522 if ( GetNumberFormat(nPara) )
1523 {
1524 const SfxBoolItem& rBulletState = (const SfxBoolItem&) pEditEngine->GetParaAttrib( nPara, EE_PARA_BULLETSTATE );
1525 return rBulletState.GetValue();
1526 }
1527 else
1528 return sal_False;
1529 }
1530
GetNumberFormat(sal_uInt16 nPara) const1531 const SvxNumberFormat* Outliner::GetNumberFormat( sal_uInt16 nPara ) const
1532 {
1533 const SvxNumberFormat* pFmt = NULL;
1534
1535 Paragraph* pPara = pParaList->GetParagraph( nPara );
1536 if (pPara == NULL)
1537 return NULL;
1538
1539 sal_Int16 nDepth = pPara? pPara->GetDepth() : -1;
1540
1541 if( nDepth >= 0 )
1542 {
1543 const SvxNumBulletItem& rNumBullet = (const SvxNumBulletItem&) pEditEngine->GetParaAttrib( nPara, EE_PARA_NUMBULLET );
1544 if ( rNumBullet.GetNumRule()->GetLevelCount() > nDepth )
1545 pFmt = rNumBullet.GetNumRule()->Get( nDepth );
1546 }
1547
1548 return pFmt;
1549 }
1550
ImplGetBulletSize(sal_uInt16 nPara)1551 Size Outliner::ImplGetBulletSize( sal_uInt16 nPara )
1552 {
1553 Paragraph* pPara = pParaList->GetParagraph( nPara );
1554 if (!pPara)
1555 return Size();
1556
1557 if( pPara->aBulSize.Width() == -1 )
1558 {
1559 const SvxNumberFormat* pFmt = GetNumberFormat( nPara );
1560 DBG_ASSERT( pFmt, "ImplGetBulletSize - no Bullet!" );
1561
1562 if ( pFmt->GetNumberingType() == SVX_NUM_NUMBER_NONE )
1563 {
1564 pPara->aBulSize = Size( 0, 0 );
1565 }
1566 else if( pFmt->GetNumberingType() != SVX_NUM_BITMAP )
1567 {
1568 String aBulletText = ImplGetBulletText( nPara );
1569 OutputDevice* pRefDev = pEditEngine->GetRefDevice();
1570 Font aBulletFont( ImpCalcBulletFont( nPara ) );
1571 Font aRefFont( pRefDev->GetFont());
1572 pRefDev->SetFont( aBulletFont );
1573 pPara->aBulSize.Width() = pRefDev->GetTextWidth( aBulletText );
1574 pPara->aBulSize.Height() = pRefDev->GetTextHeight();
1575 pRefDev->SetFont( aRefFont );
1576 }
1577 else
1578 {
1579 pPara->aBulSize = OutputDevice::LogicToLogic( pFmt->GetGraphicSize(), MAP_100TH_MM, pEditEngine->GetRefDevice()->GetMapMode() );
1580 }
1581 }
1582
1583 return pPara->aBulSize;
1584 }
1585
ImplCheckParagraphs(sal_uInt16 nStart,sal_uInt16 nEnd)1586 void Outliner::ImplCheckParagraphs( sal_uInt16 nStart, sal_uInt16 nEnd )
1587 {
1588 DBG_CHKTHIS( Outliner, 0 );
1589
1590 // --> OD 2009-03-10 #i100014#
1591 // assure that the following for-loop does not loop forever
1592 for ( sal_uInt16 n = nStart; n < nEnd; n++ )
1593 // <--
1594 {
1595 Paragraph* pPara = pParaList->GetParagraph( n );
1596 if (pPara)
1597 {
1598 pPara->Invalidate();
1599 ImplCalcBulletText( n, sal_False, sal_False );
1600 }
1601 }
1602 }
1603
SetRefDevice(OutputDevice * pRefDev)1604 void Outliner::SetRefDevice( OutputDevice* pRefDev )
1605 {
1606 DBG_CHKTHIS(Outliner,0);
1607 pEditEngine->SetRefDevice( pRefDev );
1608 for ( sal_uInt16 n = (sal_uInt16) pParaList->GetParagraphCount(); n; )
1609 {
1610 Paragraph* pPara = pParaList->GetParagraph( --n );
1611 pPara->Invalidate();
1612 }
1613 }
1614
ParaAttribsChanged(sal_uInt16 nPara)1615 void Outliner::ParaAttribsChanged( sal_uInt16 nPara )
1616 {
1617 DBG_CHKTHIS(Outliner,0);
1618
1619 // Der Outliner hat kein eigenes Undo, wenn Absaetz getrennt/verschmolzen werden.
1620 // Beim ParagraphInserted ist das Attribut EE_PARA_OUTLLEVEL
1621 // ggf. noch nicht eingestellt, dies wird aber benoetigt um die Tiefe
1622 // des Absatzes zu bestimmen.
1623
1624 if( pEditEngine->IsInUndo() )
1625 {
1626 if ( pParaList->GetParagraphCount() == pEditEngine->GetParagraphCount() )
1627 {
1628 Paragraph* pPara = pParaList->GetParagraph( nPara );
1629 const SfxInt16Item& rLevel = (const SfxInt16Item&) pEditEngine->GetParaAttrib( nPara, EE_PARA_OUTLLEVEL );
1630 if ( pPara && pPara->GetDepth() != rLevel.GetValue() )
1631 {
1632 pPara->SetDepth( rLevel.GetValue() );
1633 ImplCalcBulletText( nPara, sal_True, sal_True );
1634 }
1635 }
1636 }
1637 }
1638
StyleSheetChanged(SfxStyleSheet * pStyle)1639 void Outliner::StyleSheetChanged( SfxStyleSheet* pStyle )
1640 {
1641 DBG_CHKTHIS(Outliner,0);
1642
1643 // Die EditEngine ruft StyleSheetChanged auch fuer abgeleitete Styles.
1644 // MT: Hier wurde frueher alle Absaetze durch ein ImpRecalcParaAttribs
1645 // gejagt, die die besagte Vorlage haben, warum?
1646 // => Eigentlich kann sich nur die Bullet-Repraesentation aendern...
1647
1648 sal_uInt16 nParas = (sal_uInt16)pParaList->GetParagraphCount();
1649 for( sal_uInt16 nPara = 0; nPara < nParas; nPara++ )
1650 {
1651 if ( pEditEngine->GetStyleSheet( nPara ) == pStyle )
1652 {
1653 ImplCheckNumBulletItem( nPara );
1654 ImplCalcBulletText( nPara, sal_False, sal_False );
1655 // #97333# EditEngine formats changed paragraphs before calling this method,
1656 // so they are not reformatted now and use wrong bullet indent
1657 pEditEngine->QuickMarkInvalid( ESelection( nPara, 0, nPara, 0 ) );
1658 }
1659 }
1660 }
1661
ImpCalcBulletArea(sal_uInt16 nPara,sal_Bool bAdjust,sal_Bool bReturnPaperPos)1662 Rectangle Outliner::ImpCalcBulletArea( sal_uInt16 nPara, sal_Bool bAdjust, sal_Bool bReturnPaperPos )
1663 {
1664 // Bullet-Bereich innerhalb des Absatzes...
1665 Rectangle aBulletArea;
1666
1667 const SvxNumberFormat* pFmt = GetNumberFormat( nPara );
1668 if ( pFmt )
1669 {
1670 Point aTopLeft;
1671 Size aBulletSize( ImplGetBulletSize( nPara ) );
1672
1673 sal_Bool bOutlineMode = ( pEditEngine->GetControlWord() & EE_CNTRL_OUTLINER ) != 0;
1674
1675 // the ODF attribut text:space-before which holds the spacing to add to the left of the label
1676 const short nSpaceBefore = pFmt->GetAbsLSpace() + pFmt->GetFirstLineOffset();
1677
1678 const SvxLRSpaceItem& rLR = (const SvxLRSpaceItem&) pEditEngine->GetParaAttrib( nPara, bOutlineMode ? EE_PARA_OUTLLRSPACE : EE_PARA_LRSPACE );
1679 aTopLeft.X() = rLR.GetTxtLeft() + rLR.GetTxtFirstLineOfst() + nSpaceBefore;
1680
1681 long nBulletWidth = Max( (long) -rLR.GetTxtFirstLineOfst(), (long) ((-pFmt->GetFirstLineOffset()) + pFmt->GetCharTextDistance()) );
1682 if ( nBulletWidth < aBulletSize.Width() ) // Bullet macht sich Platz
1683 nBulletWidth = aBulletSize.Width();
1684
1685 if ( bAdjust && !bOutlineMode )
1686 {
1687 // Bei zentriert/rechtsbuendig anpassen
1688 const SvxAdjustItem& rItem = (const SvxAdjustItem&)pEditEngine->GetParaAttrib( nPara, EE_PARA_JUST );
1689 if ( ( !pEditEngine->IsRightToLeft( nPara ) && ( rItem.GetAdjust() != SVX_ADJUST_LEFT ) ) ||
1690 ( pEditEngine->IsRightToLeft( nPara ) && ( rItem.GetAdjust() != SVX_ADJUST_RIGHT ) ) )
1691 {
1692 aTopLeft.X() = pEditEngine->GetFirstLineStartX( nPara ) - nBulletWidth;
1693 }
1694 }
1695
1696 // Vertikal:
1697 ParagraphInfos aInfos = pEditEngine->GetParagraphInfos( nPara );
1698 if ( aInfos.bValid )
1699 {
1700 aTopLeft.Y() = /* aInfos.nFirstLineOffset + */ // #91076# nFirstLineOffset is already added to the StartPos (PaintBullet) from the EditEngine
1701 aInfos.nFirstLineHeight - aInfos.nFirstLineTextHeight
1702 + aInfos.nFirstLineTextHeight / 2
1703 - aBulletSize.Height() / 2;
1704 // ggf. lieber auf der Baseline ausgeben...
1705 if( ( pFmt->GetNumberingType() != SVX_NUM_NUMBER_NONE ) && ( pFmt->GetNumberingType() != SVX_NUM_BITMAP ) && ( pFmt->GetNumberingType() != SVX_NUM_CHAR_SPECIAL ) )
1706 {
1707 Font aBulletFont( ImpCalcBulletFont( nPara ) );
1708 if ( aBulletFont.GetCharSet() != RTL_TEXTENCODING_SYMBOL )
1709 {
1710 OutputDevice* pRefDev = pEditEngine->GetRefDevice();
1711 Font aOldFont = pRefDev->GetFont();
1712 pRefDev->SetFont( aBulletFont );
1713 FontMetric aMetric( pRefDev->GetFontMetric() );
1714 // Leading der ersten Zeile...
1715 aTopLeft.Y() = /* aInfos.nFirstLineOffset + */ aInfos.nFirstLineMaxAscent;
1716 aTopLeft.Y() -= aMetric.GetAscent();
1717 pRefDev->SetFont( aOldFont );
1718 }
1719 }
1720 }
1721
1722 // Horizontal:
1723 if( pFmt->GetNumAdjust() == SVX_ADJUST_RIGHT )
1724 {
1725 aTopLeft.X() += nBulletWidth - aBulletSize.Width();
1726 }
1727 else if( pFmt->GetNumAdjust() == SVX_ADJUST_CENTER )
1728 {
1729 aTopLeft.X() += ( nBulletWidth - aBulletSize.Width() ) / 2;
1730 }
1731
1732 if ( aTopLeft.X() < 0 ) // dann draengeln
1733 aTopLeft.X() = 0;
1734
1735 aBulletArea = Rectangle( aTopLeft, aBulletSize );
1736 }
1737 if ( bReturnPaperPos )
1738 {
1739 Size aBulletSize( aBulletArea.GetSize() );
1740 Point aBulletDocPos( aBulletArea.TopLeft() );
1741 aBulletDocPos.Y() += pEditEngine->GetDocPosTopLeft( nPara ).Y();
1742 Point aBulletPos( aBulletDocPos );
1743
1744 if ( IsVertical() )
1745 {
1746 aBulletPos.Y() = aBulletDocPos.X();
1747 aBulletPos.X() = GetPaperSize().Width() - aBulletDocPos.Y();
1748 // Rotate:
1749 aBulletPos.X() -= aBulletSize.Height();
1750 Size aSz( aBulletSize );
1751 aBulletSize.Width() = aSz.Height();
1752 aBulletSize.Height() = aSz.Width();
1753 }
1754 else if ( pEditEngine->IsRightToLeft( nPara ) )
1755 {
1756 aBulletPos.X() = GetPaperSize().Width() - aBulletDocPos.X() - aBulletSize.Width();
1757 }
1758
1759 aBulletArea = Rectangle( aBulletPos, aBulletSize );
1760 }
1761 return aBulletArea;
1762 }
1763
ExpandHdl()1764 void Outliner::ExpandHdl()
1765 {
1766 DBG_CHKTHIS(Outliner,0);
1767 aExpandHdl.Call( this );
1768 }
1769
GetBulletInfo(sal_uInt16 nPara)1770 EBulletInfo Outliner::GetBulletInfo( sal_uInt16 nPara )
1771 {
1772 EBulletInfo aInfo;
1773
1774 aInfo.nParagraph = nPara;
1775 aInfo.bVisible = ImplHasNumberFormat( nPara ) ? sal_True : sal_False;
1776
1777 const SvxNumberFormat* pFmt = GetNumberFormat( nPara );
1778 aInfo.nType = pFmt ? pFmt->GetNumberingType() : 0;
1779
1780 if( pFmt )
1781 {
1782 if( pFmt->GetNumberingType() != SVX_NUM_BITMAP )
1783 {
1784 aInfo.aText = ImplGetBulletText( nPara );
1785
1786 if( pFmt->GetBulletFont() )
1787 aInfo.aFont = *pFmt->GetBulletFont();
1788 }
1789 else if ( pFmt->GetBrush()->GetGraphicObject() )
1790 {
1791 aInfo.aGraphic = pFmt->GetBrush()->GetGraphicObject()->GetGraphic();
1792 }
1793 }
1794
1795 if ( aInfo.bVisible )
1796 {
1797 aInfo.aBounds = ImpCalcBulletArea( nPara, sal_True, sal_True );
1798 }
1799
1800 return aInfo;
1801 }
1802
GetText(Paragraph * pParagraph,sal_uLong nCount) const1803 XubString Outliner::GetText( Paragraph* pParagraph, sal_uLong nCount ) const
1804 {
1805 DBG_CHKTHIS(Outliner,0);
1806
1807 XubString aText;
1808 sal_uInt16 nStartPara = (sal_uInt16) pParaList->GetAbsPos( pParagraph );
1809 for ( sal_uInt16 n = 0; n < nCount; n++ )
1810 {
1811 aText += pEditEngine->GetText( nStartPara + n );
1812 if ( (n+1) < (sal_uInt16)nCount )
1813 aText += '\n';
1814 }
1815 return aText;
1816 }
1817
Remove(Paragraph * pPara,sal_uLong nParaCount)1818 void Outliner::Remove( Paragraph* pPara, sal_uLong nParaCount )
1819 {
1820 DBG_CHKTHIS(Outliner,0);
1821
1822 sal_uLong nPos = pParaList->GetAbsPos( pPara );
1823 if( !nPos && ( nParaCount >= pParaList->GetParagraphCount() ) )
1824 {
1825 Clear();
1826 }
1827 else
1828 {
1829 for( sal_uInt16 n = 0; n < (sal_uInt16)nParaCount; n++ )
1830 pEditEngine->RemoveParagraph( (sal_uInt16) nPos );
1831 }
1832 }
1833
StripPortions()1834 void Outliner::StripPortions()
1835 {
1836 DBG_CHKTHIS(Outliner,0);
1837 bStrippingPortions = sal_True;
1838 pEditEngine->StripPortions();
1839 bStrippingPortions = sal_False;
1840 }
1841
1842 // #101498#
DrawingText(const Point & rStartPos,const XubString & rText,sal_uInt16 nTextStart,sal_uInt16 nTextLen,const sal_Int32 * pDXArray,const SvxFont & rFont,sal_uInt16 nPara,sal_uInt16 nIndex,sal_uInt8 nRightToLeft,const EEngineData::WrongSpellVector * pWrongSpellVector,const SvxFieldData * pFieldData,bool bEndOfLine,bool bEndOfParagraph,bool bEndOfBullet,const::com::sun::star::lang::Locale * pLocale,const Color & rOverlineColor,const Color & rTextLineColor)1843 void Outliner::DrawingText( const Point& rStartPos, const XubString& rText, sal_uInt16 nTextStart, sal_uInt16 nTextLen, const sal_Int32* pDXArray,const SvxFont& rFont,
1844 sal_uInt16 nPara, sal_uInt16 nIndex, sal_uInt8 nRightToLeft,
1845 const EEngineData::WrongSpellVector* pWrongSpellVector,
1846 const SvxFieldData* pFieldData,
1847 bool bEndOfLine,
1848 bool bEndOfParagraph,
1849 bool bEndOfBullet,
1850 const ::com::sun::star::lang::Locale* pLocale,
1851 const Color& rOverlineColor,
1852 const Color& rTextLineColor)
1853 {
1854 DBG_CHKTHIS(Outliner,0);
1855
1856 if(aDrawPortionHdl.IsSet())
1857 {
1858 // #101498#
1859 DrawPortionInfo aInfo( rStartPos, rText, nTextStart, nTextLen, rFont, nPara, nIndex, pDXArray, pWrongSpellVector,
1860 pFieldData, pLocale, rOverlineColor, rTextLineColor, nRightToLeft, bEndOfLine, bEndOfParagraph, bEndOfBullet);
1861
1862 aDrawPortionHdl.Call( &aInfo );
1863 }
1864 }
1865
RemovingPagesHdl(OutlinerView * pView)1866 long Outliner::RemovingPagesHdl( OutlinerView* pView )
1867 {
1868 DBG_CHKTHIS(Outliner,0);
1869 return aRemovingPagesHdl.IsSet() ? aRemovingPagesHdl.Call( pView ) : sal_True;
1870 }
1871
ImpCanDeleteSelectedPages(OutlinerView * pCurView,sal_uInt16 _nFirstPage,sal_uInt16 nPages)1872 sal_Bool Outliner::ImpCanDeleteSelectedPages( OutlinerView* pCurView, sal_uInt16 _nFirstPage, sal_uInt16 nPages )
1873 {
1874 DBG_CHKTHIS(Outliner,0);
1875
1876 nDepthChangedHdlPrevDepth = nPages;
1877 mnFirstSelPage = _nFirstPage;
1878 pHdlParagraph = 0;
1879 return (sal_Bool)RemovingPagesHdl( pCurView );
1880 }
1881
GetParaAttribs(sal_uInt16 nPara)1882 SfxItemSet Outliner::GetParaAttribs( sal_uInt16 nPara )
1883 {
1884 DBG_CHKTHIS(Outliner,0);
1885 return pEditEngine->GetParaAttribs( nPara );
1886 }
1887
IMPL_LINK(Outliner,ParaVisibleStateChangedHdl,Paragraph *,pPara)1888 IMPL_LINK( Outliner, ParaVisibleStateChangedHdl, Paragraph*, pPara )
1889 {
1890 DBG_CHKTHIS(Outliner,0);
1891
1892 sal_uLong nPara = pParaList->GetAbsPos( pPara );
1893 pEditEngine->ShowParagraph( (sal_uInt16)nPara, pPara->IsVisible() );
1894
1895 return 0;
1896 }
1897
IMPL_LINK(Outliner,BeginMovingParagraphsHdl,MoveParagraphsInfo *,EMPTYARG)1898 IMPL_LINK( Outliner, BeginMovingParagraphsHdl, MoveParagraphsInfo*, EMPTYARG )
1899 {
1900 DBG_CHKTHIS(Outliner,0);
1901
1902 if( !IsInUndo() )
1903 GetBeginMovingHdl().Call( this );
1904
1905 return 0;
1906 }
1907
IMPL_LINK(Outliner,BeginPasteOrDropHdl,PasteOrDropInfos *,pInfos)1908 IMPL_LINK( Outliner, BeginPasteOrDropHdl, PasteOrDropInfos*, pInfos )
1909 {
1910 UndoActionStart( EDITUNDO_DRAGANDDROP );
1911 maBeginPasteOrDropHdl.Call(pInfos);
1912 return 0;
1913 }
1914
IMPL_LINK(Outliner,EndPasteOrDropHdl,PasteOrDropInfos *,pInfos)1915 IMPL_LINK( Outliner, EndPasteOrDropHdl, PasteOrDropInfos*, pInfos )
1916 {
1917 bPasting = sal_False;
1918 ImpTextPasted( pInfos->nStartPara, pInfos->nEndPara - pInfos->nStartPara + 1 );
1919 maEndPasteOrDropHdl.Call( pInfos );
1920 UndoActionEnd( EDITUNDO_DRAGANDDROP );
1921 return 0;
1922 }
1923
IMPL_LINK(Outliner,EndMovingParagraphsHdl,MoveParagraphsInfo *,pInfos)1924 IMPL_LINK( Outliner, EndMovingParagraphsHdl, MoveParagraphsInfo*, pInfos )
1925 {
1926 DBG_CHKTHIS(Outliner,0);
1927
1928 pParaList->MoveParagraphs( pInfos->nStartPara, pInfos->nDestPara, pInfos->nEndPara - pInfos->nStartPara + 1 );
1929 sal_uInt16 nChangesStart = Min( pInfos->nStartPara, pInfos->nDestPara );
1930 sal_uInt16 nParas = (sal_uInt16)pParaList->GetParagraphCount();
1931 for ( sal_uInt16 n = nChangesStart; n < nParas; n++ )
1932 ImplCalcBulletText( n, sal_False, sal_False );
1933
1934 if( !IsInUndo() )
1935 aEndMovingHdl.Call( this );
1936
1937 return 0;
1938 }
1939
isSameNumbering(const SvxNumberFormat & rN1,const SvxNumberFormat & rN2)1940 static bool isSameNumbering( const SvxNumberFormat& rN1, const SvxNumberFormat& rN2 )
1941 {
1942 if( rN1.GetNumberingType() != rN2.GetNumberingType() )
1943 return false;
1944
1945 if( rN1.GetNumStr(1) != rN2.GetNumStr(1) )
1946 return false;
1947
1948 if( (rN1.GetPrefix() != rN2.GetPrefix()) || (rN1.GetSuffix() != rN2.GetSuffix()) )
1949 return false;
1950
1951 return true;
1952 }
1953
ImplGetNumbering(sal_uInt16 nPara,const SvxNumberFormat * pParaFmt)1954 sal_uInt16 Outliner::ImplGetNumbering( sal_uInt16 nPara, const SvxNumberFormat* pParaFmt )
1955 {
1956 sal_uInt16 nNumber = pParaFmt->GetStart() - 1;
1957
1958 Paragraph* pPara = pParaList->GetParagraph( nPara );
1959 const sal_Int16 nParaDepth = pPara->GetDepth();
1960
1961 do
1962 {
1963 pPara = pParaList->GetParagraph( nPara );
1964 const sal_Int16 nDepth = pPara->GetDepth();
1965
1966 // ignore paragraphs that are below our paragraph or have no numbering
1967 if( (nDepth > nParaDepth) || (nDepth == -1) )
1968 continue;
1969
1970 // stop on paragraphs that are above our paragraph
1971 if( nDepth < nParaDepth )
1972 break;
1973
1974 const SvxNumberFormat* pFmt = GetNumberFormat( nPara );
1975
1976 if( pFmt == 0 )
1977 continue; // ignore paragraphs without bullets
1978
1979 // check if numbering less than or equal to pParaFmt
1980 if( !isSameNumbering( *pFmt, *pParaFmt ) || ( pFmt->GetStart() < pParaFmt->GetStart() ) )
1981 break;
1982
1983 if ( pFmt->GetStart() > pParaFmt->GetStart() )
1984 {
1985 nNumber += pFmt->GetStart() - pParaFmt->GetStart();
1986 pParaFmt = pFmt;
1987 }
1988
1989 const SfxBoolItem& rBulletState = (const SfxBoolItem&) pEditEngine->GetParaAttrib( nPara, EE_PARA_BULLETSTATE );
1990
1991 if( rBulletState.GetValue() )
1992 nNumber += 1;
1993
1994 // same depth, same number format, check for restart
1995 const sal_Int16 nNumberingStartValue = pPara->GetNumberingStartValue();
1996 if( (nNumberingStartValue != -1) || pPara->IsParaIsNumberingRestart() )
1997 {
1998 if( nNumberingStartValue != -1 )
1999 nNumber += nNumberingStartValue - 1;
2000 break;
2001 }
2002 }
2003 while( nPara-- );
2004
2005 return nNumber;
2006 }
2007
ImplCalcBulletText(sal_uInt16 nPara,sal_Bool bRecalcLevel,sal_Bool bRecalcChilds)2008 void Outliner::ImplCalcBulletText( sal_uInt16 nPara, sal_Bool bRecalcLevel, sal_Bool bRecalcChilds )
2009 {
2010 DBG_CHKTHIS(Outliner,0);
2011
2012 Paragraph* pPara = pParaList->GetParagraph( nPara );
2013 sal_uInt16 nRelPos = 0xFFFF;
2014
2015 while ( pPara )
2016 {
2017 XubString aBulletText;
2018 const SvxNumberFormat* pFmt = GetNumberFormat( nPara );
2019 if( pFmt && ( pFmt->GetNumberingType() != SVX_NUM_BITMAP ) )
2020 {
2021 aBulletText += pFmt->GetPrefix();
2022 if( pFmt->GetNumberingType() == SVX_NUM_CHAR_SPECIAL )
2023 {
2024 aBulletText += pFmt->GetBulletChar();
2025 }
2026 else if( pFmt->GetNumberingType() != SVX_NUM_NUMBER_NONE )
2027 {
2028 aBulletText += pFmt->GetNumStr( ImplGetNumbering( nPara, pFmt ) );
2029 }
2030 aBulletText += pFmt->GetSuffix();
2031 }
2032
2033 if( aBulletText != pPara->GetText() )
2034 pPara->SetText( aBulletText );
2035
2036 pPara->nFlags &= (~PARAFLAG_SETBULLETTEXT);
2037
2038 if ( bRecalcLevel )
2039 {
2040 if ( nRelPos != 0xFFFF )
2041 nRelPos++;
2042
2043 sal_Int16 nDepth = pPara->GetDepth();
2044 pPara = pParaList->GetParagraph( ++nPara );
2045 if ( !bRecalcChilds )
2046 {
2047 while ( pPara && ( pPara->GetDepth() > nDepth ) )
2048 pPara = pParaList->GetParagraph( ++nPara );
2049 }
2050
2051 if ( pPara && ( pPara->GetDepth() < nDepth ) )
2052 pPara = NULL;
2053 }
2054 else
2055 {
2056 pPara = NULL;
2057 }
2058 }
2059 }
2060
Clear()2061 void Outliner::Clear()
2062 {
2063 DBG_CHKTHIS(Outliner,0);
2064
2065 if( !bFirstParaIsEmpty )
2066 {
2067 ImplBlockInsertionCallbacks( sal_True );
2068 pEditEngine->Clear();
2069 pParaList->Clear( sal_True );
2070 pParaList->Insert( new Paragraph( nMinDepth ), LIST_APPEND );
2071 bFirstParaIsEmpty = sal_True;
2072 ImplBlockInsertionCallbacks( sal_False );
2073 }
2074 else
2075 {
2076 Paragraph* pPara = pParaList->GetParagraph( 0 );
2077 if(pPara)
2078 pPara->SetDepth( nMinDepth );
2079 }
2080 }
2081
SetFlatMode(sal_Bool bFlat)2082 void Outliner::SetFlatMode( sal_Bool bFlat )
2083 {
2084 DBG_CHKTHIS(Outliner,0);
2085
2086 if( bFlat != pEditEngine->IsFlatMode() )
2087 {
2088 for ( sal_uInt16 nPara = (sal_uInt16)pParaList->GetParagraphCount(); nPara; )
2089 pParaList->GetParagraph( --nPara )->aBulSize.Width() = -1;
2090
2091 pEditEngine->SetFlatMode( bFlat );
2092 }
2093 }
2094
ImplGetBulletText(sal_uInt16 nPara)2095 String Outliner::ImplGetBulletText( sal_uInt16 nPara )
2096 {
2097 String aRes;
2098 Paragraph* pPara = pParaList->GetParagraph( nPara );
2099 if (pPara)
2100 {
2101 // MT: Optimierung mal wieder aktivieren...
2102 // if( pPara->nFlags & PARAFLAG_SETBULLETTEXT )
2103 ImplCalcBulletText( nPara, sal_False, sal_False );
2104 aRes = pPara->GetText();
2105 }
2106 return aRes;
2107 }
2108
2109 // this is needed for StarOffice Api
SetLevelDependendStyleSheet(sal_uInt16 nPara)2110 void Outliner::SetLevelDependendStyleSheet( sal_uInt16 nPara )
2111 {
2112 SfxItemSet aOldAttrs( pEditEngine->GetParaAttribs( nPara ) );
2113 ImplSetLevelDependendStyleSheet( nPara );
2114 pEditEngine->SetParaAttribs( nPara, aOldAttrs );
2115 }
2116
2117 SV_IMPL_PTRARR( NotifyList, EENotifyPtr );
2118
ImplBlockInsertionCallbacks(sal_Bool b)2119 void Outliner::ImplBlockInsertionCallbacks( sal_Bool b )
2120 {
2121 if ( b )
2122 {
2123 bBlockInsCallback++;
2124 }
2125 else
2126 {
2127 DBG_ASSERT( bBlockInsCallback, "ImplBlockInsertionCallbacks ?!" );
2128 bBlockInsCallback--;
2129 if ( !bBlockInsCallback )
2130 {
2131 // Call blocked notify events...
2132 while ( pEditEngine->aNotifyCache.Count() )
2133 {
2134 EENotify* pNotify = pEditEngine->aNotifyCache[0];
2135 // Remove from list before calling, maybe we enter LeaveBlockNotifications while calling the handler...
2136 pEditEngine->aNotifyCache.Remove( 0 );
2137 pEditEngine->aOutlinerNotifyHdl.Call( pNotify );
2138 delete pNotify;
2139 }
2140 }
2141 }
2142 }
2143
IMPL_LINK(Outliner,EditEngineNotifyHdl,EENotify *,pNotify)2144 IMPL_LINK( Outliner, EditEngineNotifyHdl, EENotify*, pNotify )
2145 {
2146 if ( !bBlockInsCallback )
2147 {
2148 pEditEngine->aOutlinerNotifyHdl.Call( pNotify );
2149 }
2150 else
2151 {
2152 EENotify* pNewNotify = new EENotify( *pNotify );
2153 pEditEngine->aNotifyCache.Insert( pNewNotify, pEditEngine->aNotifyCache.Count() );
2154 }
2155
2156 return 0;
2157 }
2158
2159 /** sets a link that is called at the beginning of a drag operation at an edit view */
SetBeginDropHdl(const Link & rLink)2160 void Outliner::SetBeginDropHdl( const Link& rLink )
2161 {
2162 pEditEngine->SetBeginDropHdl( rLink );
2163 }
2164
GetBeginDropHdl() const2165 Link Outliner::GetBeginDropHdl() const
2166 {
2167 return pEditEngine->GetBeginDropHdl();
2168 }
2169
2170 /** sets a link that is called at the end of a drag operation at an edit view */
SetEndDropHdl(const Link & rLink)2171 void Outliner::SetEndDropHdl( const Link& rLink )
2172 {
2173 pEditEngine->SetEndDropHdl( rLink );
2174 }
2175
GetEndDropHdl() const2176 Link Outliner::GetEndDropHdl() const
2177 {
2178 return pEditEngine->GetEndDropHdl();
2179 }
2180
2181 /** sets a link that is called before a drop or paste operation. */
SetBeginPasteOrDropHdl(const Link & rLink)2182 void Outliner::SetBeginPasteOrDropHdl( const Link& rLink )
2183 {
2184 maBeginPasteOrDropHdl = rLink;
2185 }
2186
2187 /** sets a link that is called after a drop or paste operation. */
SetEndPasteOrDropHdl(const Link & rLink)2188 void Outliner::SetEndPasteOrDropHdl( const Link& rLink )
2189 {
2190 maEndPasteOrDropHdl = rLink;
2191 }
2192
SetParaFlag(Paragraph * pPara,sal_uInt16 nFlag)2193 void Outliner::SetParaFlag( Paragraph* pPara, sal_uInt16 nFlag )
2194 {
2195 if( pPara && !pPara->HasFlag( nFlag ) )
2196 {
2197 if( IsUndoEnabled() && !IsInUndo() )
2198 InsertUndo( new OutlinerUndoChangeParaFlags( this, (sal_uInt16)GetAbsPos( pPara ), pPara->nFlags, pPara->nFlags|nFlag ) );
2199
2200 pPara->SetFlag( nFlag );
2201 }
2202 }
2203
RemoveParaFlag(Paragraph * pPara,sal_uInt16 nFlag)2204 void Outliner::RemoveParaFlag( Paragraph* pPara, sal_uInt16 nFlag )
2205 {
2206 if( pPara && pPara->HasFlag( nFlag ) )
2207 {
2208 if( IsUndoEnabled() && !IsInUndo() )
2209 InsertUndo( new OutlinerUndoChangeParaFlags( this, (sal_uInt16)GetAbsPos( pPara ), pPara->nFlags, pPara->nFlags & ~nFlag ) );
2210
2211 pPara->RemoveFlag( nFlag );
2212 }
2213 }
2214
HasParaFlag(const Paragraph * pPara,sal_uInt16 nFlag) const2215 bool Outliner::HasParaFlag( const Paragraph* pPara, sal_uInt16 nFlag ) const
2216 {
2217 return pPara && pPara->HasFlag( nFlag );
2218 }
2219
2220
IsRTL() const2221 sal_Bool DrawPortionInfo::IsRTL() const
2222 {
2223 if(0xFF == mnBiDiLevel)
2224 {
2225 // Use Bidi functions from icu 2.0 to calculate if this portion
2226 // is RTL or not.
2227 UErrorCode nError(U_ZERO_ERROR);
2228 UBiDi* pBidi = ubidi_openSized(mrText.Len(), 0, &nError);
2229 nError = U_ZERO_ERROR;
2230
2231 // I do not have this info here. Is it necessary? I'll have to ask MT.
2232 const sal_uInt8 nDefaultDir = UBIDI_LTR; //IsRightToLeft( nPara ) ? UBIDI_RTL : UBIDI_LTR;
2233
2234 ubidi_setPara(pBidi, reinterpret_cast<const UChar *>(mrText.GetBuffer()), mrText.Len(), nDefaultDir, NULL, &nError); // UChar != sal_Unicode in MinGW
2235 nError = U_ZERO_ERROR;
2236
2237 // sal_Int32 nCount(ubidi_countRuns(pBidi, &nError));
2238
2239 int32_t nStart(0);
2240 int32_t nEnd;
2241 UBiDiLevel nCurrDir;
2242
2243 ubidi_getLogicalRun(pBidi, nStart, &nEnd, &nCurrDir);
2244
2245 ubidi_close(pBidi);
2246
2247 // remember on-demand calculated state
2248 ((DrawPortionInfo*)this)->mnBiDiLevel = nCurrDir;
2249 }
2250
2251 return (1 == (mnBiDiLevel % 2));
2252 }
2253
2254 // eof
2255