?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cid#1607171 Data race condition
[LibreOffice.git] / sd / source / ui / view / outlview.cxx
blob3e713c912dae268e289769ea7c0ce667f69d9229
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 <OutlineView.hxx>
21 #include <sfx2/progress.hxx>
22 #include <vcl/commandinfoprovider.hxx>
23 #include <vcl/svapp.hxx>
24 #include <svx/svxids.hrc>
25 #include <editeng/outliner.hxx>
26 #include <editeng/eeitem.hxx>
27 #include <editeng/editstat.hxx>
28 #include <editeng/lrspitem.hxx>
29 #include <svx/svdotext.hxx>
30 #include <sfx2/viewfrm.hxx>
31 #include <svl/style.hxx>
32 #include <svx/svdundo.hxx>
33 #include <editeng/numitem.hxx>
34 #include <editeng/outlobj.hxx>
35 #include <editeng/editeng.hxx>
36 #include <xmloff/autolayout.hxx>
37 #include <tools/debug.hxx>
38 #include <officecfg/Office/Common.hxx>
39
40 #include <editeng/editobj.hxx>
41 #include <editeng/editund2.hxx>
42
43 #include <editeng/editview.hxx>
44
45 #include <com/sun/star/frame/XFrame.hpp>
46
47 #include <DrawDocShell.hxx>
48 #include <drawdoc.hxx>
49 #include <Window.hxx>
50 #include <sdpage.hxx>
51 #include <pres.hxx>
52 #include <OutlineViewShell.hxx>
53 #include <app.hrc>
54 #include <strings.hrc>
55 #include <sdmod.hxx>
56 #include <sdresid.hxx>
57 #include <Outliner.hxx>
58 #include <EventMultiplexer.hxx>
59 #include <ViewShellBase.hxx>
60 #include <ViewShellManager.hxx>
61 #include <undo/undomanager.hxx>
62 #include <stlsheet.hxx>
63
64 using namespace ::com::sun::star::uno;
65 using namespace ::com::sun::star::frame;
66
67 namespace sd {
68
69 // a progress bar gets displayed when more than
70 // PROCESS_WITH_PROGRESS_THRESHOLD pages are concerned
71 #define PROCESS_WITH_PROGRESS_THRESHOLD 5
72
73 OutlineView::OutlineView(DrawDocShell& rDocSh, vcl::Window* pWindow,
74 OutlineViewShell& rOutlineViewShell)
75 : ::sd::SimpleOutlinerView(*rDocSh.GetDoc(), pWindow->GetOutDev(), &rOutlineViewShell)
76 , mrOutlineViewShell(rOutlineViewShell)
77 , mrOutliner(*mrDoc.GetOutliner())
78 , mnPagesToProcess(0)
79 , mnPagesProcessed(0)
80 , mbFirstPaint(true)
81 , maDocColor(COL_WHITE)
82 , maLRSpaceItem(SvxIndentValue::twips(2000), SvxIndentValue::zero(), SvxIndentValue::zero(),
83 EE_PARA_OUTLLRSPACE)
84 {
85 bool bInitOutliner = false;
86
87 if (mrOutliner.GetViewCount() == 0)
88 {
89 // initialize Outliner: set Reference Device
90 bInitOutliner = true;
91 mrOutliner.Init( OutlinerMode::OutlineView );
92 mrOutliner.SetRefDevice(SdModule::get()->GetVirtualRefDevice());
93 //viewsize without the width of the image and number in front
94 mnPaperWidth = (mrOutlineViewShell.GetActiveWindow()->GetViewSize().Width() - 4000);
95 mrOutliner.SetPaperSize(Size(mnPaperWidth, 400000000));
96 }
97 else
98 {
99 // width: DIN A4, two margins at 1 cm each
100 mnPaperWidth = 19000;
101 }
102
103 mpOutlinerViews[0].reset( new OutlinerView(&mrOutliner, pWindow) );
104 mpOutlinerViews[0]->SetOutputArea(::tools::Rectangle());
105 mrOutliner.SetUpdateLayout(false);
106 mrOutliner.InsertView(mpOutlinerViews[0].get(), EE_APPEND);
107
108 onUpdateStyleSettings( true );
109
110 if (bInitOutliner)
111 {
112 // fill Outliner with contents
113 FillOutliner();
114 }
115
116 Link<tools::EventMultiplexerEvent&,void> aLink( LINK(this,OutlineView,EventMultiplexerListener) );
117 mrOutlineViewShell.GetViewShellBase().GetEventMultiplexer()->AddEventListener(aLink);
118
119 Reference<XFrame> xFrame;
120 if (SfxViewFrame* pFrame = mrOutlineViewShell.GetViewShellBase().GetFrame())
121 xFrame = pFrame->GetFrame().GetFrameInterface();
122 maSlideImage = vcl::CommandInfoProvider::GetImageForCommand(u".uno:ShowSlide"_ustr, xFrame, vcl::ImageType::Size26);
123
124 // Tell undo manager of the document about the undo manager of the
125 // outliner, so that the former can synchronize with the later.
126 sd::UndoManager* pDocUndoMgr = dynamic_cast<sd::UndoManager*>(mpDocSh->GetUndoManager());
127 if (pDocUndoMgr != nullptr)
128 pDocUndoMgr->SetLinkedUndoManager(&mrOutliner.GetUndoManager());
129 }
130
131 /**
132 * Destructor, restore Links, clear Outliner
133 */
134 OutlineView::~OutlineView()
135 {
136 DBG_ASSERT(maDragAndDropModelGuard == nullptr,
137 "sd::OutlineView::~OutlineView(), prior drag operation not finished correctly!");
138
139 Link<tools::EventMultiplexerEvent&,void> aLink( LINK(this,OutlineView,EventMultiplexerListener) );
140 mrOutlineViewShell.GetViewShellBase().GetEventMultiplexer()->RemoveEventListener( aLink );
141 DisconnectFromApplication();
142
143 mpProgress.reset();
144
145 // unregister OutlinerViews and destroy them
146 for (auto & rpView : mpOutlinerViews)
147 {
148 if (rpView)
149 {
150 mrOutliner.RemoveView( rpView.get() );
151 rpView.reset();
152 }
153 }
154
155 if (mrOutliner.GetViewCount() == 0)
156 {
157 // uninitialize Outliner: enable color display
158 ResetLinks();
159 EEControlBits nCntrl = mrOutliner.GetControlWord();
160 mrOutliner.SetUpdateLayout(false); // otherwise there will be drawn on SetControlWord
161 mrOutliner.SetControlWord(nCntrl & ~EEControlBits::NOCOLORS);
162 mrOutliner.ForceAutoColor( officecfg::Office::Common::Accessibility::IsAutomaticFontColor::get() );
163 mrOutliner.Clear();
164 }
165 }
166
167 void OutlineView::ConnectToApplication()
168 {
169 // When the mode is switched to outline the main view shell grabs focus.
170 // This is done for getting cut/copy/paste commands on slides in the left
171 // pane (slide sorter view shell) to work properly.
172 SfxShell* pTopViewShell = mrOutlineViewShell.GetViewShellBase().GetViewShellManager()->GetTopViewShell();
173 if (pTopViewShell && pTopViewShell == &mrOutlineViewShell)
174 {
175 mrOutlineViewShell.GetActiveWindow()->GrabFocus();
176 }
177
178 Application::AddEventListener(LINK(this, OutlineView, AppEventListenerHdl));
179 }
180
181 void OutlineView::DisconnectFromApplication()
182 {
183 Application::RemoveEventListener(LINK(this, OutlineView, AppEventListenerHdl));
184 }
185
186 void OutlineView::Paint(const ::tools::Rectangle& rRect, ::sd::Window const * pWin)
187 {
188 OutlinerView* pOlView = GetViewByWindow(pWin);
189
190 if (pOlView)
191 {
192 pOlView->HideCursor();
193 pOlView->Paint(rRect);
194
195 pOlView->ShowCursor(mbFirstPaint);
196
197 mbFirstPaint = false;
198 }
199 }
200
201 void OutlineView::AddDeviceToPaintView(OutputDevice& rDev, vcl::Window* pWindow)
202 {
203 bool bAdded = false;
204 bool bValidArea = false;
205 ::tools::Rectangle aOutputArea;
206 const Color aWhiteColor( COL_WHITE );
207 sal_uInt16 nView = 0;
208
209 while (nView < MAX_OUTLINERVIEWS && !bAdded)
210 {
211 if (mpOutlinerViews[nView] == nullptr)
212 {
213 mpOutlinerViews[nView].reset( new OutlinerView(&mrOutliner, dynamic_cast< ::sd::Window* >(rDev.GetOwnerWindow())) );
214 mpOutlinerViews[nView]->SetBackgroundColor( aWhiteColor );
215 mrOutliner.InsertView(mpOutlinerViews[nView].get(), EE_APPEND);
216 bAdded = true;
217
218 if (bValidArea)
219 {
220 mpOutlinerViews[nView]->SetOutputArea(aOutputArea);
221 }
222 }
223 else if (!bValidArea)
224 {
225 aOutputArea = mpOutlinerViews[nView]->GetOutputArea();
226 bValidArea = true;
227 }
228
229 nView++;
230 }
231
232 // white background in Outliner
233 rDev.SetBackground( Wallpaper( aWhiteColor ) );
234
235 ::sd::View::AddDeviceToPaintView(rDev, pWindow);
236 }
237
238 void OutlineView::DeleteDeviceFromPaintView(OutputDevice& rDev)
239 {
240 bool bRemoved = false;
241 sal_uInt16 nView = 0;
242 vcl::Window* pWindow;
243
244 while (nView < MAX_OUTLINERVIEWS && !bRemoved)
245 {
246 if (mpOutlinerViews[nView] != nullptr)
247 {
248 pWindow = mpOutlinerViews[nView]->GetWindow();
249
250 if (pWindow->GetOutDev() == &rDev)
251 {
252 mrOutliner.RemoveView( mpOutlinerViews[nView].get() );
253 mpOutlinerViews[nView].reset();
254 bRemoved = true;
255 }
256 }
257
258 nView++;
259 }
260
261 ::sd::View::DeleteDeviceFromPaintView(rDev);
262 }
263
264 /**
265 * Return a pointer to the OutlinerView corresponding to the window
266 */
267 OutlinerView* OutlineView::GetViewByWindow (vcl::Window const * pWin) const
268 {
269 OutlinerView* pOlView = nullptr;
270 for (std::unique_ptr<OutlinerView> const & pView : mpOutlinerViews)
271 {
272 if (pView != nullptr)
273 {
274 if ( pWin == pView->GetWindow() )
275 {
276 pOlView = pView.get();
277 }
278 }
279 }
280 return pOlView;
281 }
282
283 /**
284 * Return the title before a random paragraph
285 */
286 Paragraph* OutlineView::GetPrevTitle(const Paragraph* pPara)
287 {
288 sal_Int32 nPos = mrOutliner.GetAbsPos(pPara);
289
290 if (nPos > 0)
291 {
292 while(nPos)
293 {
294 pPara = mrOutliner.GetParagraph(--nPos);
295 if( ::Outliner::HasParaFlag(pPara, ParaFlag::ISPAGE) )
296 {
297 return const_cast< Paragraph* >( pPara );
298 }
299 }
300
301 }
302 return nullptr;
303 }
304
305 /**
306 * Return the title after a random paragraph
307 */
308 Paragraph* OutlineView::GetNextTitle(const Paragraph* pPara)
309 {
310 Paragraph* pResult = const_cast< Paragraph* >( pPara );
311
312 sal_Int32 nPos = mrOutliner.GetAbsPos(pResult);
313
314 do
315 {
316 pResult = mrOutliner.GetParagraph(++nPos);
317 if( pResult && ::Outliner::HasParaFlag(pResult, ParaFlag::ISPAGE) )
318 return pResult;
319 }
320 while( pResult );
321
322 return nullptr;
323 }
324
325 /**
326 * Handler for inserting pages (paragraphs)
327 */
328 IMPL_LINK( OutlineView, ParagraphInsertedHdl, Outliner::ParagraphHdlParam, aParam, void )
329 {
330 // we get calls to this handler during binary insert of drag and drop contents but
331 // we ignore it here and handle it later in OnEndPasteOrDrop()
332 if (maDragAndDropModelGuard != nullptr)
333 return;
334
335 OutlineViewPageChangesGuard aGuard(this);
336
337 sal_Int32 nAbsPos = mrOutliner.GetAbsPos( aParam.pPara );
338
339 UpdateParagraph( nAbsPos );
340
341 if( (nAbsPos == 0) ||
342 ::Outliner::HasParaFlag(aParam.pPara, ParaFlag::ISPAGE) ||
343 ::Outliner::HasParaFlag(mrOutliner.GetParagraph( nAbsPos-1 ), ParaFlag::ISPAGE) )
344 {
345 InsertSlideForParagraph( aParam.pPara );
346 }
347 }
348
349 /** creates and inserts an empty slide for the given paragraph */
350 SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
351 {
352 DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::InsertSlideForParagraph(), model change without undo?!" );
353
354 OutlineViewPageChangesGuard aGuard(this);
355
356 mrOutliner.SetParaFlag( pPara, ParaFlag::ISPAGE );
357 // how many titles are there before the new title paragraph?
358 sal_uLong nExample = 0; // position of the "example" page
359 sal_uLong nTarget = 0; // position of insertion
360 while(pPara)
361 {
362 pPara = GetPrevTitle(pPara);
363 if (pPara)
364 nTarget++;
365 }
366
367 // if a new paragraph is created via RETURN before the first paragraph, the
368 // Outliner reports the old paragraph (which was moved down) as a new
369 // paragraph
370 if (nTarget == 1)
371 {
372 OUString aTest = mrOutliner.GetText(mrOutliner.GetParagraph(0));
373 if (aTest.isEmpty())
374 {
375 nTarget = 0;
376 }
377 }
378
379 // the "example" page is the previous page - if it is available
380 if (nTarget > 0)
381 {
382 nExample = nTarget - 1;
383
384 sal_uInt16 nPageCount = mrDoc.GetSdPageCount( PageKind::Standard );
385 if( nExample >= nPageCount )
386 nExample = nPageCount - 1;
387 }
388
389 /**********************************************************************
390 * All the time, a standard page is created before a notes page.
391 * It is ensured that after each standard page the corresponding notes page
392 * follows. A handout page is exactly one handout page.
393 **********************************************************************/
394
395 // this page is exemplary
396 SdPage* pExample = mrDoc.GetSdPage(static_cast<sal_uInt16>(nExample), PageKind::Standard);
397 rtl::Reference<SdPage> pPage = mrDoc.AllocSdPage(false);
398
399 pPage->SetLayoutName(pExample->GetLayoutName());
400
401 // insert (page)
402 mrDoc.InsertPage(pPage.get(), static_cast<sal_uInt16>(nTarget) * 2 + 1);
403 if( isRecordingUndo() )
404 AddUndo(mrDoc.GetSdrUndoFactory().CreateUndoNewPage(*pPage));
405
406 // assign a master page to the standard page
407 pPage->TRG_SetMasterPage(pExample->TRG_GetMasterPage());
408
409 // set page size
410 pPage->SetSize(pExample->GetSize());
411 pPage->SetBorder( pExample->GetLeftBorder(),
412 pExample->GetUpperBorder(),
413 pExample->GetRightBorder(),
414 pExample->GetLowerBorder() );
415
416 // create new presentation objects (after <Title> or <Title with subtitle>
417 // follows <Title with outline>, otherwise apply the layout of the previous
418 // page
419 AutoLayout eAutoLayout = pExample->GetAutoLayout();
420 if (eAutoLayout == AUTOLAYOUT_TITLE ||
421 eAutoLayout == AUTOLAYOUT_TITLE_ONLY)
422 {
423 pPage->SetAutoLayout(AUTOLAYOUT_TITLE_CONTENT, true);
424 }
425 else
426 {
427 pPage->SetAutoLayout(pExample->GetAutoLayout(), true);
428 }
429
430 /**********************************************************************
431 |* now the notes page
432 \*********************************************************************/
433 pExample = mrDoc.GetSdPage(static_cast<sal_uInt16>(nExample), PageKind::Notes);
434 rtl::Reference<SdPage> pNotesPage = mrDoc.AllocSdPage(false);
435
436 pNotesPage->SetLayoutName(pExample->GetLayoutName());
437
438 pNotesPage->SetPageKind(PageKind::Notes);
439
440 // insert (notes page)
441 mrDoc.InsertPage(pNotesPage.get(), static_cast<sal_uInt16>(nTarget) * 2 + 2);
442 if( isRecordingUndo() )
443 AddUndo(mrDoc.GetSdrUndoFactory().CreateUndoNewPage(*pNotesPage));
444
445 // assign a master page to the notes page
446 pNotesPage->TRG_SetMasterPage(pExample->TRG_GetMasterPage());
447
448 // set page size, there must be already one page available
449 pNotesPage->SetSize(pExample->GetSize());
450 pNotesPage->SetBorder( pExample->GetLeftBorder(),
451 pExample->GetUpperBorder(),
452 pExample->GetRightBorder(),
453 pExample->GetLowerBorder() );
454
455 // create presentation objects
456 pNotesPage->SetAutoLayout(pExample->GetAutoLayout(), true);
457
458 mrOutliner.UpdateFields();
459
460 return pPage.get();
461 }
462
463 /**
464 * Handler for deleting pages (paragraphs)
465 */
466 IMPL_LINK( OutlineView, ParagraphRemovingHdl, ::Outliner::ParagraphHdlParam, aParam, void )
467 {
468 DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::ParagraphRemovingHdl(), model change without undo?!" );
469
470 OutlineViewPageChangesGuard aGuard(this);
471
472 Paragraph* pPara = aParam.pPara;
473 if( !::Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE ) )
474 return;
475
476 // how many titles are in front of the title paragraph in question?
477 sal_uLong nPos = 0;
478 while(pPara)
479 {
480 pPara = GetPrevTitle(pPara);
481 if (pPara) nPos++;
482 }
483
484 // delete page and notes page
485 sal_uInt16 nAbsPos = static_cast<sal_uInt16>(nPos) * 2 + 1;
486 SdrPage* pPage = mrDoc.GetPage(nAbsPos);
487 if( isRecordingUndo() )
488 AddUndo(mrDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
489 mrDoc.RemovePage(nAbsPos);
490
491 nAbsPos = static_cast<sal_uInt16>(nPos) * 2 + 1;
492 pPage = mrDoc.GetPage(nAbsPos);
493 if( isRecordingUndo() )
494 AddUndo(mrDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
495 mrDoc.RemovePage(nAbsPos);
496
497 // progress display if necessary
498 if (mnPagesToProcess)
499 {
500 mnPagesProcessed++;
501
502 if(mpProgress)
503 mpProgress->SetState(mnPagesProcessed);
504
505 if (mnPagesProcessed == mnPagesToProcess)
506 {
507 mpProgress.reset();
508 mnPagesToProcess = 0;
509 mnPagesProcessed = 0;
510 }
511 }
512 aParam.pOutliner->UpdateFields();
513 }
514
515 /**
516 * Handler for changing the indentation depth of paragraphs (requires inserting
517 * or deleting of pages in some cases)
518 */
519 IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner::DepthChangeHdlParam, aParam, void )
520 {
521 DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::DepthChangedHdl(), no undo for model change?!" );
522
523 OutlineViewPageChangesGuard aGuard(this);
524
525 Paragraph* pPara = aParam.pPara;
526 ::Outliner* pOutliner = aParam.pOutliner;
527 if( ::Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE ) && ((aParam.nPrevFlags & ParaFlag::ISPAGE) == ParaFlag::NONE) )
528 {
529 // the current paragraph is transformed into a slide
530
531 mrOutliner.SetDepth( pPara, -1 );
532
533 // are multiple level 1 paragraphs being brought to level 0 and we
534 // should start a progress view or a timer and didn't already?
535 if (mnPagesToProcess == 0)
536 {
537 Window* pActWin = mrOutlineViewShell.GetActiveWindow();
538 OutlinerView* pOlView = GetViewByWindow(pActWin);
539
540 std::vector<Paragraph*> aSelList;
541 pOlView->CreateSelectionList(aSelList);
542
543 mnPagesToProcess = std::count_if(aSelList.begin(), aSelList.end(),
544 [&pOutliner](const Paragraph *pParagraph) {
545 return !Outliner::HasParaFlag(pParagraph, ParaFlag::ISPAGE) &&
546 (pOutliner->GetDepth(pOutliner->GetAbsPos(pParagraph)) <= 0);
547 });
548
549 mnPagesToProcess++; // the paragraph being in level 0 already
550 // should be included
551 mnPagesProcessed = 0;
552
553 if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD)
554 {
555 mpProgress.reset( new SfxProgress( GetDocSh(), SdResId(STR_CREATE_PAGES), mnPagesToProcess ) );
556 }
557 else
558 {
559 mpDocSh->SetWaitCursor( true );
560 }
561 }
562
563 ParagraphInsertedHdl( { aParam.pOutliner, aParam.pPara } );
564
565 mnPagesProcessed++;
566
567 // should there be a progress display?
568 if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD)
569 {
570 if (mpProgress)
571 mpProgress->SetState(mnPagesProcessed);
572 }
573
574 // was this the last page?
575 if (mnPagesProcessed == mnPagesToProcess)
576 {
577 if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD && mpProgress)
578 {
579 mpProgress.reset();
580 }
581 else
582 mpDocSh->SetWaitCursor( false );
583
584 mnPagesToProcess = 0;
585 mnPagesProcessed = 0;
586 }
587 pOutliner->UpdateFields();
588 }
589 else if( !::Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE ) && ((aParam.nPrevFlags & ParaFlag::ISPAGE) != ParaFlag::NONE) )
590 {
591 // the paragraph was a page but now becomes a normal paragraph
592
593 // how many titles are before the title paragraph in question?
594 sal_uLong nPos = 0;
595 Paragraph* pParagraph = pPara;
596 while(pParagraph)
597 {
598 pParagraph = GetPrevTitle(pParagraph);
599 if (pParagraph)
600 nPos++;
601 }
602 // delete page and notes page
603
604 sal_uInt16 nAbsPos = static_cast<sal_uInt16>(nPos) * 2 + 1;
605 SdrPage* pPage = mrDoc.GetPage(nAbsPos);
606 if( isRecordingUndo() )
607 AddUndo(mrDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
608 mrDoc.RemovePage(nAbsPos);
609
610 nAbsPos = static_cast<sal_uInt16>(nPos) * 2 + 1;
611 pPage = mrDoc.GetPage(nAbsPos);
612 if( isRecordingUndo() )
613 AddUndo(mrDoc.GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
614 mrDoc.RemovePage(nAbsPos);
615
616 pPage = GetPageForParagraph( pPara );
617
618 mrOutliner.SetDepth( pPara, (pPage && (static_cast<SdPage*>(pPage)->GetAutoLayout() == AUTOLAYOUT_TITLE)) ? -1 : 0 );
619
620 // progress display if necessary
621 if (mnPagesToProcess)
622 {
623 mnPagesProcessed++;
624 if (mpProgress)
625 mpProgress->SetState(mnPagesProcessed);
626
627 if (mnPagesProcessed == mnPagesToProcess)
628 {
629 mpProgress.reset();
630 mnPagesToProcess = 0;
631 mnPagesProcessed = 0;
632 }
633 }
634 pOutliner->UpdateFields();
635 }
636 else if ( (pOutliner->GetPrevDepth() == 1) && ( pOutliner->GetDepth( pOutliner->GetAbsPos( pPara ) ) == 2 ) )
637 {
638 // how many titles are in front of the title paragraph in question?
639 sal_Int32 nPos = -1;
640
641 Paragraph* pParagraph = pPara;
642 while(pParagraph)
643 {
644 pParagraph = GetPrevTitle(pParagraph);
645 if (pParagraph)
646 nPos++;
647 }
648
649 if(nPos >= 0)
650 {
651 SdPage*pPage = mrDoc.GetSdPage( static_cast<sal_uInt16>(nPos), PageKind::Standard);
652
653 if(pPage && pPage->GetPresObj(PresObjKind::Text))
654 pOutliner->SetDepth( pPara, 0 );
655 }
656
657 }
658 // how many titles are in front of the title paragraph in question?
659 sal_Int32 nPos = -1;
660
661 Paragraph* pTempPara = pPara;
662 while(pTempPara)
663 {
664 pTempPara = GetPrevTitle(pTempPara);
665 if (pTempPara)
666 nPos++;
667 }
668
669 if( nPos < 0 )
670 return;
671
672 SdPage* pPage = mrDoc.GetSdPage( static_cast<sal_uInt16>(nPos), PageKind::Standard );
673
674 if( !pPage )
675 return;
676
677 SfxStyleSheet* pStyleSheet = nullptr;
678 sal_Int32 nPara = pOutliner->GetAbsPos( pPara );
679 sal_Int16 nDepth = pOutliner->GetDepth( nPara );
680 bool bSubTitle = pPage->GetPresObj(PresObjKind::Text) != nullptr;
681
682 if( ::Outliner::HasParaFlag(pPara, ParaFlag::ISPAGE) )
683 {
684 pStyleSheet = pPage->GetStyleSheetForPresObj( PresObjKind::Title );
685 }
686 else if( bSubTitle )
687 {
688 pStyleSheet = pPage->GetStyleSheetForPresObj( PresObjKind::Text );
689 }
690 else
691 {
692 pStyleSheet = pPage->GetStyleSheetForPresObj( PresObjKind::Outline );
693
694 if( nDepth > 0 )
695 {
696 OUString aNewStyleSheetName = pStyleSheet->GetName();
697 if (!aNewStyleSheetName.isEmpty())
698 aNewStyleSheetName = aNewStyleSheetName.copy(0, aNewStyleSheetName.getLength() - 1);
699 aNewStyleSheetName += OUString::number( nDepth+1 );
700 SfxStyleSheetBasePool* pStylePool = mrDoc.GetStyleSheetPool();
701 pStyleSheet = static_cast<SfxStyleSheet*>( pStylePool->Find( aNewStyleSheetName, pStyleSheet->GetFamily() ) );
702 }
703 }
704
705 // before we set the style sheet we need to preserve the bullet item
706 // since all items will be deleted while setting a new style sheet
707 SfxItemSet aOldAttrs( pOutliner->GetParaAttribs( nPara ) );
708
709 pOutliner->SetStyleSheet( nPara, pStyleSheet );
710
711 // restore the old bullet item but not if the style changed
712 const SvxNumBulletItem* pBulletItem = nullptr;
713 if ( pOutliner->GetPrevDepth() != -1 && nDepth != -1 &&
714 aOldAttrs.GetItemState( EE_PARA_NUMBULLET, true, &pBulletItem ) == SfxItemState::SET )
715 {
716 SfxItemSet aAttrs( pOutliner->GetParaAttribs( nPara ) );
717 aAttrs.Put( *pBulletItem );
718 pOutliner->SetParaAttribs( nPara, aAttrs );
719 }
720 }
721
722 /**
723 * Handler for StatusEvents
724 */
725 IMPL_LINK_NOARG(OutlineView, StatusEventHdl, EditStatus&, void)
726 {
727 ::sd::Window* pWin = mrOutlineViewShell.GetActiveWindow();
728 OutlinerView* pOutlinerView = GetViewByWindow(pWin);
729 ::tools::Rectangle aVis = pOutlinerView->GetVisArea();
730 ::tools::Rectangle aText(Point(0,0),
731 Size(mnPaperWidth,
732 mrOutliner.GetTextHeight()));
733 ::tools::Rectangle aWin(Point(0,0), pWin->GetOutputSizePixel());
734 aWin = pWin->PixelToLogic(aWin);
735
736 if (!aVis.IsEmpty()) // not when opening
737 {
738 if (aWin.GetHeight() > aText.Bottom())
739 aText.SetBottom( aWin.GetHeight() );
740
741 mrOutlineViewShell.InitWindows(Point(0,0), aText.GetSize(), aVis.TopLeft());
742 mrOutlineViewShell.UpdateScrollBars();
743 }
744 }
745
746 IMPL_LINK_NOARG(OutlineView, BeginDropHdl, EditView*, void)
747 {
748 DBG_ASSERT(maDragAndDropModelGuard == nullptr,
749 "sd::OutlineView::BeginDropHdl(), prior drag operation not finished correctly!");
750
751 maDragAndDropModelGuard.reset( new OutlineViewModelChangeGuard( *this ) );
752 }
753
754 IMPL_LINK_NOARG(OutlineView, EndDropHdl, EditView*, void)
755 {
756 maDragAndDropModelGuard.reset();
757 }
758
759 /**
760 * Handler for the start of a paragraph movement
761 */
762 IMPL_LINK( OutlineView, BeginMovingHdl, ::Outliner *, pOutliner, void )
763 {
764 OutlineViewPageChangesGuard aGuard(this);
765
766 // list of selected title paragraphs
767 mpOutlinerViews[0]->CreateSelectionList(maSelectedParas);
768
769 std::erase_if(maSelectedParas,
770 [](const Paragraph* pPara) { return !Outliner::HasParaFlag(pPara, ParaFlag::ISPAGE); });
771
772 // select the pages belonging to the paragraphs on level 0 to select
773 sal_uInt16 nPos = 0;
774 sal_Int32 nParaPos = 0;
775 Paragraph* pPara = pOutliner->GetParagraph( 0 );
776 std::vector<Paragraph*>::const_iterator fiter;
777
778 while(pPara)
779 {
780 if( ::Outliner::HasParaFlag(pPara, ParaFlag::ISPAGE) ) // one page?
781 {
782 maOldParaOrder.push_back(pPara);
783 SdPage* pPage = mrDoc.GetSdPage(nPos, PageKind::Standard);
784
785 fiter = std::find(maSelectedParas.begin(),maSelectedParas.end(),pPara);
786
787 pPage->SetSelected(fiter != maSelectedParas.end());
788
789 ++nPos;
790 }
791 pPara = pOutliner->GetParagraph( ++nParaPos );
792 }
793 }
794
795 /**
796 * Handler for the end of a paragraph movement
797 */
798 IMPL_LINK( OutlineView, EndMovingHdl, ::Outliner *, pOutliner, void )
799 {
800 OutlineViewPageChangesGuard aGuard(this);
801
802 DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::EndMovingHdl(), model change without undo?!" );
803
804 // look for insertion position via the first paragraph
805 Paragraph* pSearchIt = maSelectedParas.empty() ? nullptr : *(maSelectedParas.begin());
806
807 // look for the first of the selected paragraphs in the new ordering
808 sal_uInt16 nPosNewOrder = 0;
809 sal_Int32 nParaPos = 0;
810 Paragraph* pPara = pOutliner->GetParagraph( 0 );
811 Paragraph* pPrev = nullptr;
812 while (pPara && pPara != pSearchIt)
813 {
814 if( ::Outliner::HasParaFlag(pPara, ParaFlag::ISPAGE) )
815 {
816 nPosNewOrder++;
817 pPrev = pPara;
818 }
819 pPara = pOutliner->GetParagraph( ++nParaPos );
820 }
821
822 sal_uInt16 nPos = nPosNewOrder; // don't change nPosNewOrder
823 if (nPos == 0)
824 {
825 nPos = sal_uInt16(-1); // insert before the first page
826 }
827 else
828 {
829 // look for the predecessor in the old ordering
830 std::vector<Paragraph*>::const_iterator it = std::find(maOldParaOrder.begin(),
831 maOldParaOrder.end(),
832 pPrev);
833
834 if (it != maOldParaOrder.end())
835 nPos = static_cast<sal_uInt16>(it-maOldParaOrder.begin());
836 else
837 nPos = 0xffff;
838
839 DBG_ASSERT(nPos != 0xffff, "Paragraph not found");
840 }
841
842 mrDoc.MovePages(nPos);
843
844 // deselect the pages again
845 sal_uInt16 nPageCount = static_cast<sal_uInt16>(maSelectedParas.size());
846 while (nPageCount)
847 {
848 SdPage* pPage = mrDoc.GetSdPage(nPosNewOrder, PageKind::Standard);
849 pPage->SetSelected(false);
850 nPosNewOrder++;
851 nPageCount--;
852 }
853
854 pOutliner->UpdateFields();
855
856 maSelectedParas.clear();
857 maOldParaOrder.clear();
858 }
859
860 /**
861 * Look for the title text object in one page of the model
862 */
863 SdrTextObj* OutlineView::GetTitleTextObject(SdrPage const * pPage)
864 {
865 SdrTextObj* pResult = nullptr;
866
867 for (const rtl::Reference<SdrObject>& pObject : *pPage)
868 {
869 if (pObject->GetObjInventor() == SdrInventor::Default &&
870 pObject->GetObjIdentifier() == SdrObjKind::TitleText)
871 {
872 pResult = static_cast<SdrTextObj*>(pObject.get());
873 break;
874 }
875 }
876 return pResult;
877 }
878
879 /**
880 * Look for the outline text object in one page of the model
881 */
882 SdrTextObj* OutlineView::GetOutlineTextObject(SdrPage const * pPage)
883 {
884 SdrTextObj* pResult = nullptr;
885
886 for (const rtl::Reference<SdrObject>& pObject : *pPage)
887 {
888 if (pObject->GetObjInventor() == SdrInventor::Default &&
889 pObject->GetObjIdentifier() == SdrObjKind::OutlineText)
890 {
891 pResult = static_cast<SdrTextObj*>(pObject.get());
892 break;
893 }
894 }
895 return pResult;
896 }
897
898 SdrTextObj* OutlineView::CreateTitleTextObject(SdPage* pPage)
899 {
900 DBG_ASSERT( GetTitleTextObject(pPage) == nullptr, "sd::OutlineView::CreateTitleTextObject(), there is already a title text object!" );
901
902 if( pPage->GetAutoLayout() == AUTOLAYOUT_NONE )
903 {
904 // simple case
905 pPage->SetAutoLayout( AUTOLAYOUT_TITLE_ONLY, true );
906 }
907 else
908 {
909 // we already have a layout with a title but the title
910 // object was deleted, create a new one
911 pPage->InsertAutoLayoutShape( nullptr, PresObjKind::Title, false, pPage->GetTitleRect(), true );
912 }
913
914 return GetTitleTextObject(pPage);
915 }
916
917 SdrTextObj* OutlineView::CreateOutlineTextObject(SdPage* pPage)
918 {
919 DBG_ASSERT( GetOutlineTextObject(pPage) == nullptr, "sd::OutlineView::CreateOutlineTextObject(), there is already a layout text object!" );
920
921 AutoLayout eNewLayout = pPage->GetAutoLayout();
922 switch( eNewLayout )
923 {
924 case AUTOLAYOUT_NONE:
925 case AUTOLAYOUT_TITLE_ONLY:
926 case AUTOLAYOUT_TITLE: eNewLayout = AUTOLAYOUT_TITLE_CONTENT; break;
927
928 case AUTOLAYOUT_CHART: eNewLayout = AUTOLAYOUT_CHARTTEXT; break;
929
930 case AUTOLAYOUT_ORG:
931 case AUTOLAYOUT_TAB:
932 case AUTOLAYOUT_OBJ: eNewLayout = AUTOLAYOUT_OBJTEXT; break;
933 default:
934 break;
935 }
936
937 if( eNewLayout != pPage->GetAutoLayout() )
938 {
939 pPage->SetAutoLayout( eNewLayout, true );
940 }
941 else
942 {
943 // we already have a layout with a text but the text
944 // object was deleted, create a new one
945 pPage->InsertAutoLayoutShape( nullptr,
946 PresObjKind::Outline,
947 false, pPage->GetLayoutRect(), true );
948 }
949
950 return GetOutlineTextObject(pPage);
951 }
952
953 /** updates draw model with all changes from outliner model */
954 void OutlineView::PrepareClose()
955 {
956 ::sd::UndoManager* pDocUndoMgr = dynamic_cast<sd::UndoManager*>(mpDocSh->GetUndoManager());
957 if (pDocUndoMgr != nullptr)
958 pDocUndoMgr->SetLinkedUndoManager(nullptr);
959
960 mrOutliner.GetUndoManager().Clear();
961
962 BegUndo(SdResId(STR_UNDO_CHANGE_TITLE_AND_LAYOUT));
963 UpdateDocument();
964 EndUndo();
965 mrDoc.SetSelected(GetActualPage(), true);
966 }
967
968 /**
969 * Set attributes of the selected text
970 */
971 bool OutlineView::SetAttributes(const SfxItemSet& rSet, bool /*bSlide*/, bool /*bReplaceAll*/, bool /*bMaster*/)
972 {
973 bool bOk = false;
974
975 OutlinerView* pOlView = GetViewByWindow(mrOutlineViewShell.GetActiveWindow());
976
977 if (pOlView)
978 {
979 pOlView->SetAttribs(rSet);
980 bOk = true;
981 }
982
983 mrOutlineViewShell.Invalidate (SID_PREVIEW_STATE);
984
985 return bOk;
986 }
987
988 /**
989 * Get attributes of the selected text
990 */
991 void OutlineView::GetAttributes( SfxItemSet& rTargetSet, bool ) const
992 {
993 OutlinerView* pOlView = GetViewByWindow(
994 mrOutlineViewShell.GetActiveWindow());
995 assert(pOlView && "No OutlinerView found");
996
997 rTargetSet.Put( pOlView->GetAttribs(), false );
998 }
999
1000 /** creates outliner model from draw model */
1001 void OutlineView::FillOutliner()
1002 {
1003 mrOutliner.GetUndoManager().Clear();
1004 mrOutliner.EnableUndo(false);
1005 ResetLinks();
1006 const bool bPrevUpdateLayout = mrOutliner.SetUpdateLayout(false);
1007
1008 Paragraph* pTitleToSelect = nullptr;
1009 sal_uInt16 nPageCount = mrDoc.GetSdPageCount(PageKind::Standard);
1010
1011 // fill outliner with paragraphs from slides title & (outlines|subtitles)
1012 for (sal_uInt16 nPage = 0; nPage < nPageCount; nPage++)
1013 {
1014 SdPage* pPage = mrDoc.GetSdPage(nPage, PageKind::Standard);
1015 Paragraph * pPara = nullptr;
1016
1017 // take text from title shape
1018 SdrTextObj* pTO = GetTitleTextObject(pPage);
1019 if(pTO && !(pTO->IsEmptyPresObj()))
1020 {
1021 OutlinerParaObject* pOPO = pTO->GetOutlinerParaObject();
1022 if (pOPO)
1023 {
1024 bool bVertical = pOPO->IsEffectivelyVertical();
1025 pOPO->SetVertical( false );
1026 mrOutliner.AddText(*pOPO);
1027 pOPO->SetVertical( bVertical );
1028 pPara = mrOutliner.GetParagraph( mrOutliner.GetParagraphCount()-1 );
1029 }
1030 }
1031
1032 if( pPara == nullptr ) // no title, insert an empty paragraph
1033 {
1034 pPara = mrOutliner.Insert(OUString());
1035 mrOutliner.SetDepth(pPara, -1);
1036
1037 // do not apply hard attributes from the previous paragraph
1038 mrOutliner.SetParaAttribs( mrOutliner.GetAbsPos(pPara),
1039 mrOutliner.GetEmptyItemSet() );
1040
1041 mrOutliner.SetStyleSheet( mrOutliner.GetAbsPos( pPara ), pPage->GetStyleSheetForPresObj( PresObjKind::Title ) );
1042 }
1043
1044 mrOutliner.SetParaFlag( pPara, ParaFlag::ISPAGE );
1045
1046 sal_Int32 nPara = mrOutliner.GetAbsPos( pPara );
1047
1048 UpdateParagraph( nPara );
1049
1050 // remember paragraph of currently selected page
1051 if (pPage->IsSelected())
1052 pTitleToSelect = pPara;
1053
1054 // take text from subtitle or outline
1055 pTO = static_cast<SdrTextObj*>(pPage->GetPresObj(PresObjKind::Text));
1056 const bool bSubTitle = pTO != nullptr;
1057
1058 if (!pTO) // if no subtile found, try outline
1059 pTO = GetOutlineTextObject(pPage);
1060
1061 if(pTO && !(pTO->IsEmptyPresObj())) // found some text
1062 {
1063 OutlinerParaObject* pOPO = pTO->GetOutlinerParaObject();
1064 if (pOPO)
1065 {
1066 sal_Int32 nParaCount1 = mrOutliner.GetParagraphCount();
1067 bool bVertical = pOPO->IsEffectivelyVertical();
1068 pOPO->SetVertical( false );
1069 mrOutliner.AddText(*pOPO);
1070 pOPO->SetVertical( bVertical );
1071
1072 sal_Int32 nParaCount2 = mrOutliner.GetParagraphCount();
1073 for (sal_Int32 n = nParaCount1; n < nParaCount2; n++)
1074 {
1075 if( bSubTitle )
1076 {
1077 Paragraph* p = mrOutliner.GetParagraph(n);
1078 if(p && mrOutliner.GetDepth( n ) > 0 )
1079 mrOutliner.SetDepth(p, 0);
1080 }
1081
1082 UpdateParagraph( n );
1083 }
1084 }
1085 }
1086 }
1087
1088 // place cursor at the start
1089 Paragraph* pFirstPara = mrOutliner.GetParagraph( 0 );
1090 mpOutlinerViews[0]->Select( pFirstPara );
1091 mpOutlinerViews[0]->Select( pFirstPara, false );
1092
1093 // select title of slide that was selected
1094 if (pTitleToSelect)
1095 mpOutlinerViews[0]->Select(pTitleToSelect);
1096
1097 SetLinks();
1098
1099 mrOutliner.EnableUndo(true);
1100
1101 mrOutliner.SetUpdateLayout(bPrevUpdateLayout);
1102 }
1103
1104 /**
1105 * Handler for deleting of level 0 paragraphs (pages): Warning
1106 */
1107 IMPL_LINK_NOARG(OutlineView, RemovingPagesHdl, OutlinerView*, bool)
1108 {
1109 sal_Int32 nNumOfPages = mrOutliner.GetSelPageCount();
1110
1111 if (nNumOfPages > PROCESS_WITH_PROGRESS_THRESHOLD)
1112 {
1113 mnPagesToProcess = nNumOfPages;
1114 mnPagesProcessed = 0;
1115 }
1116
1117 if (mnPagesToProcess)
1118 {
1119 mpProgress.reset( new SfxProgress( GetDocSh(), SdResId(STR_DELETE_PAGES), mnPagesToProcess ) );
1120 }
1121 mrOutliner.UpdateFields();
1122
1123 return true;
1124 }
1125
1126 /**
1127 * Handler for indenting level 0 paragraphs (pages): Warning
1128 */
1129 IMPL_LINK( OutlineView, IndentingPagesHdl, OutlinerView *, pOutlinerView, bool )
1130 {
1131 return RemovingPagesHdl(pOutlinerView);
1132 }
1133
1134 /** returns the first slide that is selected in the outliner or where
1135 the cursor is located */
1136 SdPage* OutlineView::GetActualPage()
1137 {
1138 ::sd::Window* pWin = mrOutlineViewShell.GetActiveWindow();
1139 OutlinerView* pActiveView = GetViewByWindow(pWin);
1140
1141 std::vector<Paragraph*> aSelList;
1142 pActiveView->CreateSelectionList(aSelList);
1143
1144 Paragraph *pPar = aSelList.empty() ? nullptr : *(aSelList.begin());
1145 SdPage* pCurrent = GetPageForParagraph(pPar);
1146
1147 DBG_ASSERT( pCurrent ||
1148 (mpDocSh->GetUndoManager() && static_cast< sd::UndoManager *>(mpDocSh->GetUndoManager())->IsDoing()) ||
1149 maDragAndDropModelGuard,
1150 "sd::OutlineView::GetActualPage(), no current page?" );
1151
1152 if( pCurrent )
1153 return pCurrent;
1154
1155 return mrDoc.GetSdPage( 0, PageKind::Standard );
1156 }
1157
1158 SdPage* OutlineView::GetPageForParagraph( Paragraph* pPara )
1159 {
1160 if( !::Outliner::HasParaFlag(pPara,ParaFlag::ISPAGE) )
1161 pPara = GetPrevTitle(pPara);
1162
1163 sal_uInt32 nPageToSelect = 0;
1164 while(pPara)
1165 {
1166 pPara = GetPrevTitle(pPara);
1167 if(pPara)
1168 nPageToSelect++;
1169 }
1170
1171 if( nPageToSelect < static_cast<sal_uInt32>(mrDoc.GetSdPageCount( PageKind::Standard )) )
1172 return mrDoc.GetSdPage( static_cast<sal_uInt16>(nPageToSelect), PageKind::Standard );
1173
1174 return nullptr;
1175 }
1176
1177 Paragraph* OutlineView::GetParagraphForPage( ::Outliner const & rOutl, SdPage const * pPage )
1178 {
1179 // get the number of paragraphs with ident 0 we need to skip before
1180 // we find the actual page
1181 sal_uInt16 nPageNum = pPage->GetPageNum();
1182 assert(nPageNum > 0);
1183 sal_uInt32 nPagesToSkip = (nPageNum - 1) >> 1;
1184
1185 sal_Int32 nParaPos = 0;
1186 Paragraph* pPara = rOutl.GetParagraph( 0 );
1187 while( pPara )
1188 {
1189 // if this paragraph is a page...
1190 if( ::Outliner::HasParaFlag(pPara,ParaFlag::ISPAGE) )
1191 {
1192 // see if we already skipped enough pages
1193 if( 0 == nPagesToSkip )
1194 break; // and if so, end the loop
1195
1196 // we skipped another page
1197 nPagesToSkip--;
1198 }
1199
1200 // get next paragraph
1201 pPara = mrOutliner.GetParagraph( ++nParaPos );
1202 }
1203
1204 return pPara;
1205 }
1206
1207 /** selects the paragraph for the given page at the outliner view*/
1208 void OutlineView::SetActualPage( SdPage const * pActual )
1209 {
1210 if( pActual && mrOutliner.GetIgnoreCurrentPageChangesLevel()==0 && !mbFirstPaint)
1211 {
1212 // if we found a paragraph, select its text at the outliner view
1213 Paragraph* pPara = GetParagraphForPage( mrOutliner, pActual );
1214 if( pPara )
1215 mpOutlinerViews[0]->Select( pPara );
1216 }
1217 }
1218
1219 /**
1220 * Get StyleSheet from the selection
1221 */
1222 SfxStyleSheet* OutlineView::GetStyleSheet() const
1223 {
1224 ::sd::Window* pActWin = mrOutlineViewShell.GetActiveWindow();
1225 OutlinerView* pOlView = GetViewByWindow(pActWin);
1226 SfxStyleSheet* pResult = pOlView->GetStyleSheet();
1227 return pResult;
1228 }
1229
1230 /**
1231 * Mark pages as selected / not selected
1232 */
1233 void OutlineView::SetSelectedPages()
1234 {
1235 // list of selected title paragraphs
1236 std::vector<Paragraph*> aSelParas;
1237 mpOutlinerViews[0]->CreateSelectionList(aSelParas);
1238
1239 std::erase_if(aSelParas,
1240 [](const Paragraph* pPara) { return !Outliner::HasParaFlag(pPara, ParaFlag::ISPAGE); });
1241
1242 // select the pages belonging to the paragraphs on level 0 to select
1243 sal_uInt16 nPos = 0;
1244 sal_Int32 nParaPos = 0;
1245 Paragraph *pPara = mrOutliner.GetParagraph( 0 );
1246 std::vector<Paragraph*>::const_iterator fiter;
1247
1248 while(pPara)
1249 {
1250 if( ::Outliner::HasParaFlag(pPara, ParaFlag::ISPAGE) ) // one page
1251 {
1252 SdPage* pPage = mrDoc.GetSdPage(nPos, PageKind::Standard);
1253 DBG_ASSERT(pPage!=nullptr,
1254 "Trying to select non-existing page OutlineView::SetSelectedPages()");
1255
1256 if (pPage)
1257 {
1258 fiter = std::find(aSelParas.begin(),aSelParas.end(),pPara);
1259 pPage->SetSelected(fiter != aSelParas.end());
1260 }
1261
1262 nPos++;
1263 }
1264
1265 pPara = mrOutliner.GetParagraph( ++nParaPos );
1266 }
1267 }
1268
1269 /**
1270 * Set new links
1271 */
1272 void OutlineView::SetLinks()
1273 {
1274 // set notification links
1275 mrOutliner.SetParaInsertedHdl(LINK(this, OutlineView, ParagraphInsertedHdl));
1276 mrOutliner.SetParaRemovingHdl(LINK(this, OutlineView, ParagraphRemovingHdl));
1277 mrOutliner.SetDepthChangedHdl(LINK(this, OutlineView, DepthChangedHdl));
1278 mrOutliner.SetBeginMovingHdl(LINK(this, OutlineView, BeginMovingHdl));
1279 mrOutliner.SetEndMovingHdl(LINK(this, OutlineView, EndMovingHdl));
1280 mrOutliner.SetRemovingPagesHdl(LINK(this, OutlineView, RemovingPagesHdl));
1281 mrOutliner.SetIndentingPagesHdl(LINK(this, OutlineView, IndentingPagesHdl));
1282 mrOutliner.SetStatusEventHdl(LINK(this, OutlineView, StatusEventHdl));
1283 mrOutliner.SetBeginDropHdl(LINK(this,OutlineView, BeginDropHdl));
1284 mrOutliner.SetEndDropHdl(LINK(this,OutlineView, EndDropHdl));
1285 mrOutliner.SetPaintFirstLineHdl(LINK(this,OutlineView,PaintingFirstLineHdl));
1286 mrOutliner.SetBeginPasteOrDropHdl(LINK(this,OutlineView, BeginPasteOrDropHdl));
1287 mrOutliner.SetEndPasteOrDropHdl(LINK(this,OutlineView, EndPasteOrDropHdl));
1288 }
1289
1290 /**
1291 * Restore old links
1292 */
1293 void OutlineView::ResetLinks() const
1294 {
1295 mrOutliner.SetParaInsertedHdl(Link<::Outliner::ParagraphHdlParam,void>());
1296 mrOutliner.SetParaRemovingHdl(Link<::Outliner::ParagraphHdlParam,void>());
1297 mrOutliner.SetDepthChangedHdl(Link<::Outliner::DepthChangeHdlParam,void>());
1298 mrOutliner.SetBeginMovingHdl(Link<::Outliner*,void>());
1299 mrOutliner.SetEndMovingHdl(Link<::Outliner*,void>());
1300 mrOutliner.SetStatusEventHdl(Link<EditStatus&,void>());
1301 mrOutliner.SetRemovingPagesHdl(Link<OutlinerView*,bool>());
1302 mrOutliner.SetIndentingPagesHdl(Link<OutlinerView*,bool>());
1303 mrOutliner.SetDrawPortionHdl(Link<DrawPortionInfo*,void>());
1304 mrOutliner.SetBeginPasteOrDropHdl(Link<PasteOrDropInfos*,void>());
1305 mrOutliner.SetEndPasteOrDropHdl(Link<PasteOrDropInfos*,void>());
1306 }
1307
1308 sal_Int8 OutlineView::AcceptDrop( const AcceptDropEvent&, DropTargetHelper&, SdrLayerID)
1309 {
1310 return DND_ACTION_NONE;
1311 }
1312
1313 sal_Int8 OutlineView::ExecuteDrop( const ExecuteDropEvent&, ::sd::Window*, sal_uInt16, SdrLayerID)
1314 {
1315 return DND_ACTION_NONE;
1316 }
1317
1318 // Re-implement GetScriptType for this view to get correct results
1319 SvtScriptType OutlineView::GetScriptType() const
1320 {
1321 SvtScriptType nScriptType = ::sd::View::GetScriptType();
1322
1323 std::optional<OutlinerParaObject> pTempOPObj = mrOutliner.CreateParaObject();
1324 if(pTempOPObj)
1325 {
1326 nScriptType = pTempOPObj->GetTextObject().GetScriptType();
1327 }
1328
1329 return nScriptType;
1330 }
1331
1332 void OutlineView::onUpdateStyleSettings( bool bForceUpdate /* = false */ )
1333 {
1334 svtools::ColorConfig aColorConfig;
1335 const Color aDocColor( aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor );
1336 if( !(bForceUpdate || (maDocColor != aDocColor)) )
1337 return;
1338
1339 sal_uInt16 nView;
1340 for( nView = 0; nView < MAX_OUTLINERVIEWS; nView++ )
1341 {
1342 if (mpOutlinerViews[nView] != nullptr)
1343 {
1344 mpOutlinerViews[nView]->SetBackgroundColor( aDocColor );
1345
1346 vcl::Window* pWindow = mpOutlinerViews[nView]->GetWindow();
1347
1348 if( pWindow )
1349 pWindow->SetBackground( Wallpaper( aDocColor ) );
1350
1351 }
1352 }
1353
1354 mrOutliner.SetBackgroundColor( aDocColor );
1355
1356 maDocColor = aDocColor;
1357 }
1358
1359 IMPL_LINK_NOARG(OutlineView, AppEventListenerHdl, VclSimpleEvent&, void)
1360 {
1361 onUpdateStyleSettings(false);
1362 }
1363
1364 IMPL_LINK(OutlineView, EventMultiplexerListener, ::sd::tools::EventMultiplexerEvent&, rEvent, void)
1365 {
1366 switch (rEvent.meEventId)
1367 {
1368 case EventMultiplexerEventId::CurrentPageChanged:
1369 SetActualPage(mrOutlineViewShell.GetActualPage());
1370 break;
1371
1372 case EventMultiplexerEventId::PageOrder:
1373 if (mrOutliner.GetIgnoreCurrentPageChangesLevel()==0)
1374 {
1375 if (((mrDoc.GetPageCount()-1)%2) == 0)
1376 {
1377 mrOutliner.Clear();
1378 FillOutliner();
1379 ::sd::Window* pWindow = mrOutlineViewShell.GetActiveWindow();
1380 if (pWindow != nullptr)
1381 pWindow->Invalidate();
1382 }
1383 }
1384 break;
1385
1386 default: break;
1387 }
1388 }
1389
1390 void OutlineView::IgnoreCurrentPageChanges (bool bIgnoreChanges)
1391 {
1392 if (bIgnoreChanges)
1393 mrOutliner.IncreIgnoreCurrentPageChangesLevel();
1394 else
1395 mrOutliner.DecreIgnoreCurrentPageChangesLevel();
1396 }
1397
1398 /** call this method before you do anything that can modify the outliner
1399 and or the drawing document model. It will create needed undo actions */
1400 void OutlineView::BeginModelChange()
1401 {
1402 mrOutliner.GetUndoManager().EnterListAction(u""_ustr, u""_ustr, 0, mrOutlineViewShell.GetViewShellBase().GetViewShellId());
1403 BegUndo(SdResId(STR_UNDO_CHANGE_TITLE_AND_LAYOUT));
1404 }
1405
1406 /** call this method after BeginModelChange(), when all possible model
1407 changes are done. */
1408 void OutlineView::EndModelChange()
1409 {
1410 UpdateDocument();
1411
1412 SfxUndoManager* pDocUndoMgr = mpDocSh->GetUndoManager();
1413
1414 bool bHasUndoActions = pDocUndoMgr->GetUndoActionCount() != 0;
1415
1416 EndUndo();
1417
1418 DBG_ASSERT( bHasUndoActions == (mrOutliner.GetUndoManager().GetUndoActionCount() != 0), "sd::OutlineView::EndModelChange(), undo actions not in sync!" );
1419
1420 mrOutliner.GetUndoManager().LeaveListAction();
1421
1422 if( bHasUndoActions && mrOutliner.GetEditEngine().HasTriedMergeOnLastAddUndo() )
1423 TryToMergeUndoActions();
1424
1425 mrOutlineViewShell.Invalidate( SID_UNDO );
1426 mrOutlineViewShell.Invalidate( SID_REDO );
1427 }
1428
1429 /** updates all changes in the outliner model to the draw model */
1430 void OutlineView::UpdateDocument()
1431 {
1432 OutlineViewPageChangesGuard aGuard(this);
1433
1434 const sal_uInt32 nPageCount = mrDoc.GetSdPageCount(PageKind::Standard);
1435 Paragraph* pPara = mrOutliner.GetParagraph( 0 );
1436 sal_uInt32 nPage;
1437 for (nPage = 0; nPage < nPageCount; nPage++)
1438 {
1439 SdPage* pPage = mrDoc.GetSdPage( static_cast<sal_uInt16>(nPage), PageKind::Standard);
1440 mrDoc.SetSelected(pPage, false);
1441
1442 mrOutlineViewShell.UpdateTitleObject( pPage, pPara );
1443 mrOutlineViewShell.UpdateOutlineObject( pPage, pPara );
1444
1445 if( pPara )
1446 pPara = GetNextTitle(pPara);
1447 }
1448
1449 DBG_ASSERT( pPara == nullptr, "sd::OutlineView::UpdateDocument(), slides are out of sync, creating missing ones" );
1450 while( pPara )
1451 {
1452 SdPage* pPage = InsertSlideForParagraph( pPara );
1453 mrDoc.SetSelected(pPage, false);
1454
1455 mrOutlineViewShell.UpdateTitleObject( pPage, pPara );
1456 mrOutlineViewShell.UpdateOutlineObject( pPage, pPara );
1457
1458 pPara = GetNextTitle(pPara);
1459 }
1460 }
1461
1462 /** merge edit engine undo actions if possible */
1463 void OutlineView::TryToMergeUndoActions()
1464 {
1465 SfxUndoManager& rOutlineUndo = mrOutliner.GetUndoManager();
1466 if( rOutlineUndo.GetUndoActionCount() <= 1 )
1467 return;
1468
1469 SfxListUndoAction* pListAction = dynamic_cast< SfxListUndoAction* >( rOutlineUndo.GetUndoAction() );
1470 SfxListUndoAction* pPrevListAction = dynamic_cast< SfxListUndoAction* >( rOutlineUndo.GetUndoAction(1) );
1471 if( !(pListAction && pPrevListAction) )
1472 return;
1473
1474 // find the top EditUndo action in the top undo action list
1475 size_t nAction = pListAction->maUndoActions.size();
1476 EditUndo* pEditUndo = nullptr;
1477 while( !pEditUndo && nAction )
1478 {
1479 pEditUndo = dynamic_cast< EditUndo* >(pListAction->GetUndoAction(--nAction));
1480 }
1481
1482 sal_uInt16 nEditPos = nAction; // we need this later to remove the merged undo actions
1483
1484 // make sure it is the only EditUndo action in the top undo list
1485 while( pEditUndo && nAction )
1486 {
1487 if( dynamic_cast< EditUndo* >(pListAction->GetUndoAction(--nAction)) )
1488 pEditUndo = nullptr;
1489 }
1490
1491 // do we have one and only one EditUndo action in the top undo list?
1492 if( !pEditUndo )
1493 return;
1494
1495 // yes, see if we can merge it with the prev undo list
1496
1497 nAction = pPrevListAction->maUndoActions.size();
1498 EditUndo* pPrevEditUndo = nullptr;
1499 while( !pPrevEditUndo && nAction )
1500 pPrevEditUndo = dynamic_cast< EditUndo* >(pPrevListAction->GetUndoAction(--nAction));
1501
1502 if( !(pPrevEditUndo && pPrevEditUndo->Merge( pEditUndo )) )
1503 return;
1504
1505 // ok we merged the only EditUndo of the top undo list with
1506 // the top EditUndo of the previous undo list
1507
1508 // first remove the merged undo action
1509 assert( pListAction->GetUndoAction(nEditPos) == pEditUndo &&
1510 "sd::OutlineView::TryToMergeUndoActions(), wrong edit pos!" );
1511 pListAction->Remove(nEditPos);
1512
1513 if ( !pListAction->maUndoActions.empty() )
1514 {
1515 // now we have to move all remaining doc undo actions from the top undo
1516 // list to the previous undo list and remove the top undo list
1517
1518 size_t nCount = pListAction->maUndoActions.size();
1519 size_t nDestAction = pPrevListAction->maUndoActions.size();
1520 while( nCount-- )
1521 {
1522 std::unique_ptr<SfxUndoAction> pTemp = pListAction->Remove(0);
1523 pPrevListAction->Insert( std::move(pTemp), nDestAction++ );
1524 }
1525 pPrevListAction->nCurUndoAction = pPrevListAction->maUndoActions.size();
1526 }
1527
1528 rOutlineUndo.RemoveLastUndoAction();
1529 }
1530
1531 IMPL_LINK(OutlineView, PaintingFirstLineHdl, PaintFirstLineInfo*, pInfo, void)
1532 {
1533 if( !pInfo )
1534 return;
1535
1536 Paragraph* pPara = mrOutliner.GetParagraph( pInfo->mnPara );
1537 EditEngine& rEditEngine = const_cast< EditEngine& >( mrOutliner.GetEditEngine() );
1538
1539 Size aImageSize( pInfo->mpOutDev->PixelToLogic( maSlideImage.GetSizePixel() ) );
1540 Size aOffset( 100, 100 );
1541
1542 // paint slide number
1543 if( !(pPara && ::Outliner::HasParaFlag(pPara,ParaFlag::ISPAGE)) )
1544 return;
1545
1546 ::tools::Long nPage = 0; // todo, printing??
1547 for ( sal_Int32 n = 0; n <= pInfo->mnPara; n++ )
1548 {
1549 Paragraph* p = mrOutliner.GetParagraph( n );
1550 if ( ::Outliner::HasParaFlag(p,ParaFlag::ISPAGE) )
1551 nPage++;
1552 }
1553
1554 ::tools::Long nBulletHeight = static_cast<::tools::Long>(mrOutliner.GetLineHeight( pInfo->mnPara ));
1555 ::tools::Long nFontHeight = 0;
1556 if ( !rEditEngine.IsFlatMode() )
1557 {
1558 nFontHeight = nBulletHeight / 5;
1559 }
1560 else
1561 {
1562 nFontHeight = (nBulletHeight * 10) / 25;
1563 }
1564
1565 Size aFontSz( 0, nFontHeight );
1566
1567 Size aOutSize( 2000, nBulletHeight );
1568
1569 const float fImageHeight = (static_cast<float>(aOutSize.Height()) * float(4)) / float(7);
1570 if (aImageSize.Width() != 0)
1571 {
1572 const float fImageRatio = static_cast<float>(aImageSize.Height()) / static_cast<float>(aImageSize.Width());
1573 aImageSize.setWidth( static_cast<::tools::Long>( fImageRatio * fImageHeight ) );
1574 }
1575 aImageSize.setHeight( static_cast<::tools::Long>(fImageHeight) );
1576
1577 Point aImagePos( pInfo->mrStartPos );
1578 aImagePos.AdjustX(aOutSize.Width() - aImageSize.Width() - aOffset.Width() ) ;
1579 aImagePos.AdjustY((aOutSize.Height() - aImageSize.Height()) / 2 );
1580
1581 pInfo->mpOutDev->DrawImage( aImagePos, aImageSize, maSlideImage );
1582
1583 const bool bVertical = mrOutliner.IsVertical();
1584 const bool bRightToLeftPara = rEditEngine.IsRightToLeft( pInfo->mnPara );
1585
1586 LanguageType eLang = rEditEngine.GetDefaultLanguage();
1587
1588 Point aTextPos( aImagePos.X() - aOffset.Width(), pInfo->mrStartPos.Y() );
1589 vcl::Font aNewFont( OutputDevice::GetDefaultFont( DefaultFontType::SANS_UNICODE, eLang, GetDefaultFontFlags::NONE ) );
1590 aNewFont.SetFontSize( aFontSz );
1591 aNewFont.SetVertical( bVertical );
1592 aNewFont.SetOrientation( Degree10(bVertical ? 2700 : 0) );
1593 aNewFont.SetColor( COL_AUTO );
1594 pInfo->mpOutDev->SetFont( aNewFont );
1595 OUString aPageText = OUString::number( nPage );
1596 Size aTextSz;
1597 aTextSz.setWidth( pInfo->mpOutDev->GetTextWidth( aPageText ) );
1598 aTextSz.setHeight( pInfo->mpOutDev->GetTextHeight() );
1599 if ( !bVertical )
1600 {
1601 aTextPos.AdjustY((aOutSize.Height() - aTextSz.Height()) / 2 );
1602 if ( !bRightToLeftPara )
1603 {
1604 aTextPos.AdjustX( -(aTextSz.Width()) );
1605 }
1606 else
1607 {
1608 aTextPos.AdjustX(aTextSz.Width() );
1609 }
1610 }
1611 else
1612 {
1613 aTextPos.AdjustY( -(aTextSz.Width()) );
1614 aTextPos.AdjustX(nBulletHeight / 2 );
1615 }
1616 pInfo->mpOutDev->DrawText( aTextPos, aPageText );
1617 }
1618
1619 void OutlineView::UpdateParagraph( sal_Int32 nPara )
1620 {
1621 SfxItemSet aNewAttrs2( mrOutliner.GetParaAttribs( nPara ) );
1622 aNewAttrs2.Put( maLRSpaceItem );
1623 mrOutliner.SetParaAttribs( nPara, aNewAttrs2 );
1624 }
1625
1626 void OutlineView::OnBeginPasteOrDrop( PasteOrDropInfos* /*pInfo*/ )
1627 {
1628 }
1629
1630 /** this is called after a paste or drop operation, make sure that the newly inserted paragraphs
1631 get the correct style sheet and new slides are inserted. */
1632 void OutlineView::OnEndPasteOrDrop( PasteOrDropInfos* pInfo )
1633 {
1634 SdPage* pPage = nullptr;
1635 SfxStyleSheetBasePool* pStylePool = GetDoc().GetStyleSheetPool();
1636
1637 for( sal_Int32 nPara = pInfo->nStartPara; nPara <= pInfo->nEndPara; nPara++ )
1638 {
1639 Paragraph* pPara = mrOutliner.GetParagraph( nPara );
1640
1641 bool bPage = ::Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE );
1642
1643 if( !bPage )
1644 {
1645 SdStyleSheet* pStyleSheet = dynamic_cast< SdStyleSheet* >( mrOutliner.GetStyleSheet( nPara ) );
1646 if( pStyleSheet )
1647 {
1648 if ( pStyleSheet->GetApiName() == "title" )
1649 bPage = true;
1650 }
1651 }
1652
1653 if( !pPara )
1654 continue; // fatality!?
1655
1656 if( bPage && (nPara != pInfo->nStartPara) )
1657 {
1658 // insert new slide for this paragraph
1659 pPage = InsertSlideForParagraph( pPara );
1660 }
1661 else
1662 {
1663 // newly inserted non page paragraphs get the outline style
1664 if( !pPage )
1665 pPage = GetPageForParagraph( pPara );
1666
1667 if( pPage )
1668 {
1669 SfxStyleSheet* pStyle = pPage->GetStyleSheetForPresObj( bPage ? PresObjKind::Title : PresObjKind::Outline );
1670
1671 if( !bPage )
1672 {
1673 const sal_Int16 nDepth = mrOutliner.GetDepth( nPara );
1674 if( nDepth > 0 )
1675 {
1676 OUString aStyleSheetName = pStyle->GetName();
1677 if (!aStyleSheetName.isEmpty())
1678 aStyleSheetName = aStyleSheetName.copy(0, aStyleSheetName.getLength() - 1);
1679 aStyleSheetName += OUString::number( nDepth );
1680 pStyle = static_cast<SfxStyleSheet*>( pStylePool->Find( aStyleSheetName, pStyle->GetFamily() ) );
1681 DBG_ASSERT( pStyle, "sd::OutlineView::OnEndPasteOrDrop(), Style not found!" );
1682 }
1683 }
1684
1685 mrOutliner.SetStyleSheet( nPara, pStyle );
1686 }
1687
1688 UpdateParagraph( nPara );
1689 }
1690 }
1691 }
1692
1693
1694 OutlineViewModelChangeGuard::OutlineViewModelChangeGuard( OutlineView& rView )
1695 : mrView( rView )
1696 {
1697 mrView.BeginModelChange();
1698 }
1699
1700 OutlineViewModelChangeGuard::~OutlineViewModelChangeGuard() COVERITY_NOEXCEPT_FALSE
1701 {
1702 mrView.EndModelChange();
1703 }
1704
1705
1706 OutlineViewPageChangesGuard::OutlineViewPageChangesGuard( OutlineView* pView )
1707 : mpView( pView )
1708 {
1709 if( mpView )
1710 mpView->IgnoreCurrentPageChanges( true );
1711 }
1712
1713 OutlineViewPageChangesGuard::~OutlineViewPageChangesGuard()
1714 {
1715 if( mpView )
1716 mpView->IgnoreCurrentPageChanges( false );
1717 }
1718
1719 } // end of namespace sd
1720
1721 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE