sw/source/core/doc/docdraw.cxx

   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  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 #include <hintids.hxx>
  20 #include <editeng/flditem.hxx>
  21 #include <editeng/editeng.hxx>
  22 #include <editeng/colritem.hxx>
  23 #include <svx/svdpage.hxx>
  24 #include <svx/svdogrp.hxx>
  25 #include <editeng/measfld.hxx>
  26 #include <sal/log.hxx>
  27 #include <osl/diagnose.h>
  28 #include <fmtanchr.hxx>
  29 #include <charatr.hxx>
  30 #include <frmfmt.hxx>
  31 #include <charfmt.hxx>
  32 #include <viewimp.hxx>
  33 #include <doc.hxx>
  34 #include <docfunc.hxx>
  35 #include <IDocumentUndoRedo.hxx>
  36 #include <IDocumentDrawModelAccess.hxx>
  37 #include <IDocumentState.hxx>
  38 #include <IDocumentLayoutAccess.hxx>
  39 #include <IDocumentStylePoolAccess.hxx>
  40 #include <poolfmt.hxx>
  41 #include <drawdoc.hxx>
  42 #include <UndoDraw.hxx>
  43 #include <swundo.hxx>
  44 #include <dcontact.hxx>
  45 #include <dview.hxx>
  46 #include <mvsave.hxx>
  47 #include <flyfrm.hxx>
  48 #include <dflyobj.hxx>
  49 #include <txtfrm.hxx>
  50 #include <editeng/frmdiritem.hxx>
  51 #include <fmtornt.hxx>
  52 #include <svx/svditer.hxx>
  53
  54 #include <vector>
  55
  56 using namespace ::com::sun::star;
  57 using namespace ::com::sun::star::linguistic2;
  58
  59 /** local method to determine positioning and alignment attributes for a drawing
  60  *  object, which is newly connected to the layout.
  61  *
  62  * Used for a newly formed group object <SwDoc::GroupSelection(..)>
  63  * and the members of a destroyed group <SwDoc::UnGroupSelection(..)>
  64  */
  65 static void lcl_AdjustPositioningAttr( SwDrawFrameFormat* _pFrameFormat,
  66                                 const SdrObject& _rSdrObj )
  67 {
  68     const SwContact* pContact = GetUserCall( &_rSdrObj );
  69     OSL_ENSURE( pContact, "<lcl_AdjustPositioningAttr(..)> - missing contact object." );
  70
  71     // determine position of new group object relative to its anchor frame position
  72     SwTwips nHoriRelPos = 0;
  73     SwTwips nVertRelPos = 0;
  74     {
  75         const SwFrame* pAnchorFrame = pContact->GetAnchoredObj( &_rSdrObj )->GetAnchorFrame();
  76         OSL_ENSURE( !pAnchorFrame ||
  77                 !pAnchorFrame->IsTextFrame() ||
  78                 !static_cast<const SwTextFrame*>(pAnchorFrame)->IsFollow(),
  79                 "<lcl_AdjustPositioningAttr(..)> - anchor frame is a follow." );
  80         bool bVert = false;
  81         bool bR2L = false;
  82         // #i45952# - use anchor position of anchor frame, if it exist.
  83         Point aAnchorPos;
  84         if ( pAnchorFrame )
  85         {
  86             // #i45952#
  87             aAnchorPos = pAnchorFrame->GetFrameAnchorPos( ::HasWrap( &_rSdrObj ) );
  88             bVert = pAnchorFrame->IsVertical();
  89             bR2L = pAnchorFrame->IsRightToLeft();
  90         }
  91         else
  92         {
  93             // #i45952#
  94             aAnchorPos = _rSdrObj.GetAnchorPos();
  95             // If no anchor frame exist - e.g. because no layout exists - the
  96             // default layout direction is taken.
  97             const SvxFrameDirectionItem& rDirItem =
  98                 _pFrameFormat->GetAttrSet().GetPool()->GetDefaultItem( RES_FRAMEDIR );
  99             switch ( rDirItem.GetValue() )
 100             {
 101                 case SvxFrameDirection::Vertical_LR_TB:
 102                 {
 103                     // vertical from left-to-right
 104                     bVert = true;
 105                     bR2L = true;
 106                     OSL_FAIL( "<lcl_AdjustPositioningAttr(..)> - vertical from left-to-right not supported." );
 107                 }
 108                 break;
 109                 case SvxFrameDirection::Vertical_RL_TB:
 110                 {
 111                     // vertical from right-to-left
 112                     bVert = true;
 113                     bR2L = false;
 114                 }
 115                 break;
 116                 case SvxFrameDirection::Horizontal_RL_TB:
 117                 {
 118                     // horizontal from right-to-left
 119                     bVert = false;
 120                     bR2L = true;
 121                 }
 122                 break;
 123                 case SvxFrameDirection::Horizontal_LR_TB:
 124                 {
 125                     // horizontal from left-to-right
 126                     bVert = false;
 127                     bR2L = false;
 128                 }
 129                 break;
 130                 case SvxFrameDirection::Environment:
 131                     SAL_WARN("sw.core", "lcl_AdjustPositioningAttr(..) SvxFrameDirection::Environment not supported");
 132                     break;
 133                 default: break;
 134             }
 135
 136         }
 137         // use geometry of drawing object
 138         const tools::Rectangle aObjRect = _rSdrObj.GetSnapRect();
 139
 140         if ( bVert )
 141         {
 142             if ( bR2L ) {
 143                   //SvxFrameDirection::Vertical_LR_TB
 144                   nHoriRelPos = aObjRect.Left() - aAnchorPos.getX();
 145                   nVertRelPos = aObjRect.Top() - aAnchorPos.getY();
 146             } else {
 147                 //SvxFrameDirection::Vertical_RL_TB
 148                 nHoriRelPos = aObjRect.Top() - aAnchorPos.getY();
 149                 nVertRelPos = aAnchorPos.getX() - aObjRect.Right();
 150             }
 151         }
 152         else if ( bR2L )
 153         {
 154             nHoriRelPos = aAnchorPos.getX() - aObjRect.Right();
 155             nVertRelPos = aObjRect.Top() - aAnchorPos.getY();
 156         }
 157         else
 158         {
 159             nHoriRelPos = aObjRect.Left() - aAnchorPos.getX();
 160             nVertRelPos = aObjRect.Top() - aAnchorPos.getY();
 161         }
 162     }
 163
 164     _pFrameFormat->SetFormatAttr( SwFormatHoriOrient( nHoriRelPos, text::HoriOrientation::NONE, text::RelOrientation::FRAME ) );
 165     _pFrameFormat->SetFormatAttr( SwFormatVertOrient( nVertRelPos, text::VertOrientation::NONE, text::RelOrientation::FRAME ) );
 166     // #i44334#, #i44681# - positioning attributes already set
 167     _pFrameFormat->PosAttrSet();
 168     // #i34750# - keep current object rectangle for  drawing
 169     // objects. The object rectangle is used on events from the drawing layer
 170     // to adjust the positioning attributes - see <SwDrawContact::Changed_(..)>.
 171     {
 172         const SwAnchoredObject* pAnchoredObj = pContact->GetAnchoredObj( &_rSdrObj );
 173         if ( auto pAnchoredDrawObj = dynamic_cast<const SwAnchoredDrawObject*>( pAnchoredObj) )
 174         {
 175             const tools::Rectangle aObjRect = _rSdrObj.GetSnapRect();
 176             const_cast<SwAnchoredDrawObject*>(pAnchoredDrawObj)
 177                                         ->SetLastObjRect( aObjRect );
 178         }
 179     }
 180 }
 181
 182 SwDrawContact* SwDoc::GroupSelection( SdrView& rDrawView )
 183 {
 184     // replace marked 'virtual' drawing objects by the corresponding 'master'
 185     // drawing objects.
 186     SwDrawView::ReplaceMarkedDrawVirtObjs( rDrawView );
 187
 188     const SdrMarkList &rMrkList = rDrawView.GetMarkedObjectList();
 189     SdrObject *pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
 190     bool bNoGroup = ( nullptr == pObj->getParentSdrObjectFromSdrObject() );
 191     SwDrawContact* pNewContact = nullptr;
 192     if( bNoGroup )
 193     {
 194         SwDrawFrameFormat *pFormat = nullptr;
 195
 196         // Revoke anchor attribute.
 197         SwDrawContact *pMyContact = static_cast<SwDrawContact*>(GetUserCall(pObj));
 198         const SwFormatAnchor aAnch( pMyContact->GetFormat()->GetAnchor() );
 199
 200         std::unique_ptr<SwUndoDrawGroup> pUndo;
 201         if (GetIDocumentUndoRedo().DoesUndo())
 202             pUndo.reset(new SwUndoDrawGroup( o3tl::narrowing<sal_uInt16>(rMrkList.GetMarkCount()), *this));
 203
 204         // #i53320#
 205         bool bGroupMembersNotPositioned( false );
 206         {
 207             SwAnchoredDrawObject* pAnchoredDrawObj =
 208                 static_cast<SwAnchoredDrawObject*>(pMyContact->GetAnchoredObj( pObj ));
 209             bGroupMembersNotPositioned = pAnchoredDrawObj->NotYetPositioned();
 210         }
 211
 212         std::map<const SdrObject*, SwFrameFormat*> vSavedTextBoxes;
 213         // Destroy ContactObjects and formats.
 214         for( size_t i = 0; i < rMrkList.GetMarkCount(); ++i )
 215         {
 216             pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
 217             SwDrawContact *pContact = static_cast<SwDrawContact*>(GetUserCall(pObj));
 218
 219             // #i53320#
 220 #if OSL_DEBUG_LEVEL > 0
 221             SwAnchoredDrawObject* pAnchoredDrawObj =
 222                 static_cast<SwAnchoredDrawObject*>(pContact->GetAnchoredObj( pObj ));
 223             OSL_ENSURE( bGroupMembersNotPositioned == pAnchoredDrawObj->NotYetPositioned(),
 224                     "<SwDoc::GroupSelection(..)> - group members have different positioning status!" );
 225 #endif
 226             // Before the format will be killed, save its textbox for later use.
 227             if (auto pShapeFormat = pContact->GetFormat())
 228                 if (auto pTextBoxNode = pShapeFormat->GetOtherTextBoxFormats())
 229                     for (const auto& rTextBoxElement : pTextBoxNode->GetAllTextBoxes())
 230                         vSavedTextBoxes.emplace(rTextBoxElement);
 231
 232             pFormat = static_cast<SwDrawFrameFormat*>(pContact->GetFormat());
 233             // Deletes itself!
 234             pContact->Changed(*pObj, SdrUserCallType::Delete, pObj->GetLastBoundRect() );
 235             pObj->SetUserCall( nullptr );
 236
 237             if( pUndo )
 238                 pUndo->AddObj( i, pFormat, pObj );
 239             else
 240                 DelFrameFormat( pFormat );
 241
 242             // #i45952# - re-introduce position normalization of group member
 243             // objects, because its anchor position is cleared, when they are
 244             // grouped.
 245             Point aAnchorPos( pObj->GetAnchorPos() );
 246             pObj->NbcSetAnchorPos( Point( 0, 0 ) );
 247             pObj->NbcMove( Size( aAnchorPos.getX(), aAnchorPos.getY() ) );
 248         }
 249
 250         pFormat = MakeDrawFrameFormat( GetUniqueDrawObjectName(),
 251                                 GetDfltFrameFormat() );
 252         pFormat->SetFormatAttr( aAnch );
 253         // #i36010# - set layout direction of the position
 254         pFormat->SetPositionLayoutDir(
 255             text::PositionLayoutDir::PositionInLayoutDirOfAnchor );
 256
 257         // Add the saved textboxes to the new format.
 258         auto pTextBoxNode = std::make_shared<SwTextBoxNode>(
 259             SwTextBoxNode(static_cast<SwFrameFormat*>(pFormat)));
 260         for (const auto& pTextBoxEntry : vSavedTextBoxes)
 261         {
 262             pTextBoxNode->AddTextBox(const_cast<SdrObject*>(pTextBoxEntry.first),
 263                                      pTextBoxEntry.second);
 264             pTextBoxEntry.second->SetOtherTextBoxFormats(pTextBoxNode);
 265         }
 266         pFormat->SetOtherTextBoxFormats(pTextBoxNode);
 267         vSavedTextBoxes.clear();
 268
 269         rDrawView.GroupMarked();
 270         OSL_ENSURE( rMrkList.GetMarkCount() == 1, "GroupMarked more or none groups." );
 271
 272         SdrObject* pNewGroupObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
 273         pNewGroupObj->SetName(pFormat->GetName());
 274         pNewContact = new SwDrawContact( pFormat, pNewGroupObj );
 275         // #i35635#
 276         pNewContact->MoveObjToVisibleLayer( pNewGroupObj );
 277         pNewContact->ConnectToLayout();
 278         // #i53320# - No adjustment of the positioning and alignment
 279         // attributes, if group members aren't positioned yet.
 280         if ( !bGroupMembersNotPositioned )
 281         {
 282             // #i26791# - Adjust positioning and alignment attributes.
 283             lcl_AdjustPositioningAttr( pFormat, *pNewGroupObj );
 284         }
 285
 286         if( pUndo )
 287         {
 288             pUndo->SetGroupFormat( pFormat );
 289             GetIDocumentUndoRedo().AppendUndo( std::move(pUndo) );
 290         }
 291     }
 292     else
 293     {
 294         if (GetIDocumentUndoRedo().DoesUndo())
 295         {
 296             GetIDocumentUndoRedo().ClearRedo();
 297         }
 298
 299         rDrawView.GroupMarked();
 300         OSL_ENSURE( rMrkList.GetMarkCount() == 1, "GroupMarked more or none groups." );
 301     }
 302
 303     return pNewContact;
 304 }
 305
 306 static void lcl_CollectTextBoxesForSubGroupObj(SwFrameFormat* pTargetFormat, std::shared_ptr<SwTextBoxNode> pTextBoxNode,
 307                                                SdrObject* pSourceObjs)
 308 {
 309     if (auto pChildrenObjs = pSourceObjs->getChildrenOfSdrObject())
 310         for (size_t i = 0; i < pChildrenObjs->GetObjCount(); ++i)
 311             lcl_CollectTextBoxesForSubGroupObj(pTargetFormat, pTextBoxNode, pChildrenObjs->GetObj(i));
 312     else
 313     {
 314         if (auto pTextBox = pTextBoxNode->GetTextBox(pSourceObjs))
 315         {
 316             if (!pTargetFormat->GetOtherTextBoxFormats())
 317             {
 318                 pTargetFormat->SetOtherTextBoxFormats(std::make_shared<SwTextBoxNode>(SwTextBoxNode(pTargetFormat)));
 319             }
 320             pTargetFormat->GetOtherTextBoxFormats()->AddTextBox(pSourceObjs, pTextBox);
 321             pTextBox->SetOtherTextBoxFormats(pTargetFormat->GetOtherTextBoxFormats());
 322         }
 323     }
 324 }
 325
 326
 327 void SwDoc::UnGroupSelection( SdrView& rDrawView )
 328 {
 329     bool const bUndo = GetIDocumentUndoRedo().DoesUndo();
 330     if( bUndo )
 331     {
 332         GetIDocumentUndoRedo().ClearRedo();
 333     }
 334
 335     // replace marked 'virtual' drawing objects by the corresponding 'master'
 336     // drawing objects.
 337     SwDrawView::ReplaceMarkedDrawVirtObjs( rDrawView );
 338
 339     const SdrMarkList &rMrkList = rDrawView.GetMarkedObjectList();
 340     std::unique_ptr<std::vector< std::pair< SwDrawFrameFormat*, SdrObject* > >[]> pFormatsAndObjs;
 341     const size_t nMarkCount( rMrkList.GetMarkCount() );
 342     if ( nMarkCount )
 343     {
 344         pFormatsAndObjs.reset( new std::vector< std::pair< SwDrawFrameFormat*, SdrObject* > >[nMarkCount] );
 345         SdrObject *pMyObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
 346         if( !pMyObj->getParentSdrObjectFromSdrObject() )
 347         {
 348             for ( size_t i = 0; i < nMarkCount; ++i )
 349             {
 350                 SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
 351                 if ( auto pObjGroup = dynamic_cast<SdrObjGroup*>(pObj) )
 352                 {
 353                     SwDrawContact *pContact = static_cast<SwDrawContact*>(GetUserCall(pObj));
 354
 355                     std::shared_ptr<SwTextBoxNode> pTextBoxNode;
 356                     if (auto pGroupFormat = pContact->GetFormat())
 357                         pTextBoxNode = pGroupFormat->GetOtherTextBoxFormats();
 358
 359                     SwFormatAnchor aAnch( pContact->GetFormat()->GetAnchor() );
 360                     SdrObjList *pLst = pObjGroup->GetSubList();
 361
 362                     SwUndoDrawUnGroup* pUndo = nullptr;
 363                     if( bUndo )
 364                     {
 365                         pUndo = new SwUndoDrawUnGroup( pObjGroup, *this );
 366                         GetIDocumentUndoRedo().AppendUndo(std::unique_ptr<SwUndo>(pUndo));
 367                     }
 368
 369                     for ( size_t i2 = 0; i2 < pLst->GetObjCount(); ++i2 )
 370                     {
 371                         SdrObject* pSubObj = pLst->GetObj( i2 );
 372                         SwDrawFrameFormat *pFormat = MakeDrawFrameFormat( GetUniqueShapeName(),
 373                                                             GetDfltFrameFormat() );
 374                         pFormat->SetFormatAttr( aAnch );
 375
 376                         if (pTextBoxNode)
 377                         {
 378                             if (!pObj->getChildrenOfSdrObject())
 379                             {
 380                                 if (auto pTextBoxFormat = pTextBoxNode->GetTextBox(pSubObj))
 381                                 {
 382                                     auto pNewTextBoxNode =std::make_shared<SwTextBoxNode>(SwTextBoxNode(pFormat));
 383                                     pNewTextBoxNode->AddTextBox(pSubObj, pTextBoxFormat);
 384                                     pFormat->SetOtherTextBoxFormats(pNewTextBoxNode);
 385                                     pTextBoxFormat->SetOtherTextBoxFormats(pNewTextBoxNode);
 386                                 }
 387                             }
 388                             else
 389                             {
 390                                 lcl_CollectTextBoxesForSubGroupObj(pFormat, pTextBoxNode, pSubObj);
 391                             }
 392                         }
 393                         // #i36010# - set layout direction of the position
 394                         pFormat->SetPositionLayoutDir(
 395                             text::PositionLayoutDir::PositionInLayoutDirOfAnchor );
 396                         if (pSubObj->GetName().isEmpty())
 397                             pSubObj->SetName(pFormat->GetName());
 398                         pFormatsAndObjs[i].emplace_back( pFormat, pSubObj );
 399
 400                         if( bUndo )
 401                             pUndo->AddObj( o3tl::narrowing<sal_uInt16>(i2), pFormat );
 402                     }
 403                 }
 404             }
 405         }
 406     }
 407     rDrawView.UnGroupMarked();
 408     // creation of <SwDrawContact> instances for the former group members and
 409     // its connection to the Writer layout.
 410     for ( size_t i = 0; i < nMarkCount; ++i )
 411     {
 412         SwUndoDrawUnGroupConnectToLayout* pUndo = nullptr;
 413         if( bUndo )
 414         {
 415             pUndo = new SwUndoDrawUnGroupConnectToLayout(*this);
 416             GetIDocumentUndoRedo().AppendUndo(std::unique_ptr<SwUndo>(pUndo));
 417         }
 418
 419         while ( !pFormatsAndObjs[i].empty() )
 420         {
 421             SwDrawFrameFormat* pFormat( pFormatsAndObjs[i].back().first );
 422             SdrObject* pObj( pFormatsAndObjs[i].back().second );
 423             pFormatsAndObjs[i].pop_back();
 424
 425             SwDrawContact* pContact = new SwDrawContact( pFormat, pObj );
 426             pContact->MoveObjToVisibleLayer( pObj );
 427             pContact->ConnectToLayout();
 428             lcl_AdjustPositioningAttr( pFormat, *pObj );
 429
 430             if ( bUndo )
 431             {
 432                 pUndo->AddFormatAndObj( pFormat, pObj );
 433             }
 434         }
 435     }
 436 }
 437
 438 bool SwDoc::DeleteSelection( SwDrawView& rDrawView )
 439 {
 440     bool bCallBase = false;
 441     const SdrMarkList &rMrkList = rDrawView.GetMarkedObjectList();
 442     if( rMrkList.GetMarkCount() )
 443     {
 444         GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
 445         bool bDelMarked = true;
 446
 447         if( 1 == rMrkList.GetMarkCount() )
 448         {
 449             SdrObject *pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
 450             if( auto pDrawObj = dynamic_cast<SwVirtFlyDrawObj*>( pObj) )
 451             {
 452                 SwFlyFrameFormat* pFrameFormat = pDrawObj->GetFlyFrame()->GetFormat();
 453                 if( pFrameFormat )
 454                 {
 455                     getIDocumentLayoutAccess().DelLayoutFormat( pFrameFormat );
 456                     bDelMarked = false;
 457                 }
 458             }
 459         }
 460
 461         for( size_t i = 0; i < rMrkList.GetMarkCount(); ++i )
 462         {
 463             SdrObject *pObj = rMrkList.GetMark( i )->GetMarkedSdrObj();
 464             if( dynamic_cast<const SwVirtFlyDrawObj*>( pObj) ==  nullptr )
 465             {
 466                 SwDrawContact *pC = static_cast<SwDrawContact*>(GetUserCall(pObj));
 467                 SwDrawFrameFormat *pFrameFormat = static_cast<SwDrawFrameFormat*>(pC->GetFormat());
 468                 if( pFrameFormat &&
 469                     RndStdIds::FLY_AS_CHAR == pFrameFormat->GetAnchor().GetAnchorId() )
 470                 {
 471                     rDrawView.MarkObj( pObj, rDrawView.Imp().GetPageView(), true );
 472                     --i;
 473                     getIDocumentLayoutAccess().DelLayoutFormat( pFrameFormat );
 474                 }
 475             }
 476         }
 477
 478         if( rMrkList.GetMarkCount() && bDelMarked )
 479         {
 480             SdrObject *pObj = rMrkList.GetMark( 0 )->GetMarkedSdrObj();
 481             if( !pObj->getParentSdrObjectFromSdrObject() )
 482             {
 483                 std::unique_ptr<SwUndoDrawDelete> pUndo;
 484                 if (GetIDocumentUndoRedo().DoesUndo())
 485                     pUndo.reset(new SwUndoDrawDelete( o3tl::narrowing<sal_uInt16>(rMrkList.GetMarkCount()), *this ));
 486
 487                 // Destroy ContactObjects, save formats.
 488                 for( size_t i = 0; i < rMrkList.GetMarkCount(); ++i )
 489                 {
 490                     const SdrMark& rMark = *rMrkList.GetMark( i );
 491                     pObj = rMark.GetMarkedSdrObj();
 492                     SwDrawContact *pContact = static_cast<SwDrawContact*>(pObj->GetUserCall());
 493                     if( pContact ) // of course not for grouped objects
 494                     {
 495                         SwDrawFrameFormat *pFormat = static_cast<SwDrawFrameFormat*>(pContact->GetFormat());
 496                         // before delete of selection is performed, marked
 497                         // <SwDrawVirtObj>-objects have to be replaced by its
 498                         // reference objects.  Thus, assert, if a
 499                         // <SwDrawVirt>-object is found in the mark list.
 500                         if ( dynamic_cast<const SwDrawVirtObj*>( pObj) !=  nullptr )
 501                         {
 502                             OSL_FAIL( "<SwDrawVirtObj> is still marked for delete. application will crash!" );
 503                         }
 504                         // Deletes itself!
 505                         pContact->Changed(*pObj, SdrUserCallType::Delete, pObj->GetLastBoundRect() );
 506                         pObj->SetUserCall( nullptr );
 507
 508                         if( pUndo )
 509                             pUndo->AddObj( pFormat, rMark );
 510                         else
 511                             DelFrameFormat( pFormat );
 512                     }
 513                 }
 514
 515                 if( pUndo )
 516                 {
 517                     GetIDocumentUndoRedo().AppendUndo( std::move(pUndo) );
 518                 }
 519             }
 520             bCallBase = true;
 521         }
 522         getIDocumentState().SetModified();
 523
 524         GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
 525     }
 526
 527     return bCallBase;
 528 }
 529
 530 ZSortFly::ZSortFly(const SwFrameFormat* pFrameFormat, const SwFormatAnchor* pFlyAn, sal_uInt32 nArrOrdNum)
 531     : m_pFormat(pFrameFormat)
 532     , m_pAnchor(pFlyAn)
 533     , m_nOrdNum(nArrOrdNum)
 534 {
 535     SAL_WARN_IF(m_pFormat->Which() != RES_FLYFRMFMT && m_pFormat->Which() != RES_DRAWFRMFMT, "sw.core", "What kind of format is this?");
 536     m_pFormat->CallSwClientNotify(sw::GetZOrderHint(m_nOrdNum));
 537 }
 538
 539 /// In the Outliner, set a link to the method for field display in edit objects.
 540 void SwDoc::SetCalcFieldValueHdl(Outliner* pOutliner)
 541 {
 542     pOutliner->SetCalcFieldValueHdl(LINK(this, SwDoc, CalcFieldValueHdl));
 543 }
 544
 545 /// Recognise fields/URLs in the Outliner and set how they are displayed.
 546 IMPL_LINK(SwDoc, CalcFieldValueHdl, EditFieldInfo*, pInfo, void)
 547 {
 548     if (!pInfo)
 549         return;
 550
 551     const SvxFieldItem& rField = pInfo->GetField();
 552     const SvxFieldData* pField = rField.GetField();
 553
 554     if (auto pDateField = dynamic_cast<const SvxDateField*>( pField))
 555     {
 556         // Date field
 557         pInfo->SetRepresentation(
 558             pDateField->GetFormatted(
 559                     *GetNumberFormatter(), LANGUAGE_SYSTEM) );
 560     }
 561     else if (auto pURLField = dynamic_cast<const SvxURLField*>( pField))
 562     {
 563         // URL field
 564         switch ( pURLField->GetFormat() )
 565         {
 566             case SvxURLFormat::AppDefault: //!!! Can be set in App???
 567             case SvxURLFormat::Repr:
 568                 pInfo->SetRepresentation(pURLField->GetRepresentation());
 569                 break;
 570
 571             case SvxURLFormat::Url:
 572                 pInfo->SetRepresentation(pURLField->GetURL());
 573                 break;
 574         }
 575
 576         sal_uInt16 nChrFormat;
 577
 578         if (IsVisitedURL(pURLField->GetURL()))
 579             nChrFormat = RES_POOLCHR_INET_VISIT;
 580         else
 581             nChrFormat = RES_POOLCHR_INET_NORMAL;
 582
 583         SwFormat *pFormat = getIDocumentStylePoolAccess().GetCharFormatFromPool(nChrFormat);
 584
 585         Color aColor(COL_LIGHTBLUE);
 586         if (pFormat)
 587             aColor = pFormat->GetColor().GetValue();
 588
 589         pInfo->SetTextColor(aColor);
 590     }
 591     else if (dynamic_cast<const SdrMeasureField*>( pField))
 592     {
 593         // Clear measure field
 594         pInfo->SetFieldColor(std::optional<Color>());
 595     }
 596     else if ( auto pTimeField = dynamic_cast<const SvxExtTimeField*>( pField) )
 597     {
 598         // Time field
 599         pInfo->SetRepresentation(
 600             pTimeField->GetFormatted(*GetNumberFormatter(), LANGUAGE_SYSTEM) );
 601     }
 602     else
 603     {
 604         OSL_FAIL("unknown field command");
 605         pInfo->SetRepresentation( OUString( '?' ) );
 606     }
 607 }
 608
 609 // #i62875#
 610 namespace docfunc
 611 {
 612     bool ExistsDrawObjs( SwDoc& p_rDoc )
 613     {
 614         bool bExistsDrawObjs( false );
 615
 616         if ( p_rDoc.getIDocumentDrawModelAccess().GetDrawModel() &&
 617              p_rDoc.getIDocumentDrawModelAccess().GetDrawModel()->GetPage( 0 ) )
 618         {
 619             const SdrPage& rSdrPage( *(p_rDoc.getIDocumentDrawModelAccess().GetDrawModel()->GetPage( 0 )) );
 620
 621             SdrObjListIter aIter( &rSdrPage, SdrIterMode::Flat );
 622             while( aIter.IsMore() )
 623             {
 624                 SdrObject* pObj( aIter.Next() );
 625                 if ( !dynamic_cast<SwVirtFlyDrawObj*>(pObj) &&
 626                      !dynamic_cast<SwFlyDrawObj*>(pObj) )
 627                 {
 628                     bExistsDrawObjs = true;
 629                     break;
 630                 }
 631             }
 632         }
 633
 634         return bExistsDrawObjs;
 635     }
 636
 637     bool AllDrawObjsOnPage( SwDoc& p_rDoc )
 638     {
 639         bool bAllDrawObjsOnPage( true );
 640
 641         if ( p_rDoc.getIDocumentDrawModelAccess().GetDrawModel() &&
 642              p_rDoc.getIDocumentDrawModelAccess().GetDrawModel()->GetPage( 0 ) )
 643         {
 644             const SdrPage& rSdrPage( *(p_rDoc.getIDocumentDrawModelAccess().GetDrawModel()->GetPage( 0 )) );
 645
 646             SdrObjListIter aIter( &rSdrPage, SdrIterMode::Flat );
 647             while( aIter.IsMore() )
 648             {
 649                 SdrObject* pObj( aIter.Next() );
 650                 if ( !dynamic_cast<SwVirtFlyDrawObj*>(pObj) &&
 651                      !dynamic_cast<SwFlyDrawObj*>(pObj) )
 652                 {
 653                     SwDrawContact* pDrawContact =
 654                             dynamic_cast<SwDrawContact*>(::GetUserCall( pObj ));
 655                     if ( pDrawContact )
 656                     {
 657                         SwAnchoredDrawObject* pAnchoredDrawObj =
 658                             dynamic_cast<SwAnchoredDrawObject*>(pDrawContact->GetAnchoredObj( pObj ));
 659
 660                         // error handling
 661                         {
 662                             if ( !pAnchoredDrawObj )
 663                             {
 664                                 OSL_FAIL( "<docfunc::AllDrawObjsOnPage() - missing anchored draw object" );
 665                                 bAllDrawObjsOnPage = false;
 666                                 break;
 667                             }
 668                         }
 669
 670                         if ( pAnchoredDrawObj->NotYetPositioned() )
 671                         {
 672                             // The drawing object isn't yet layouted.
 673                             // Thus, it isn't known, if all drawing objects are on page.
 674                             bAllDrawObjsOnPage = false;
 675                             break;
 676                         }
 677                         else if ( pAnchoredDrawObj->IsOutsidePage() )
 678                         {
 679                             bAllDrawObjsOnPage = false;
 680                             break;
 681                         }
 682                     }
 683                     else
 684                     {
 685                         // contact object of drawing object doesn't exists.
 686                         // Thus, the drawing object isn't yet positioned.
 687                         // Thus, it isn't known, if all drawing objects are on page.
 688                         bAllDrawObjsOnPage = false;
 689                         break;
 690                     }
 691                 }
 692             }
 693         }
 694
 695         return bAllDrawObjsOnPage;
 696     }
 697 }
 698
 699 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */