svx/source/sidebar/SelectionAnalyzer.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  *
   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 <svx/sidebar/SelectionAnalyzer.hxx>
  21 #include <svx/svdmark.hxx>
  22 #include <svx/svdobj.hxx>
  23 #include <svx/svdotext.hxx>
  24 #include <svx/svdpage.hxx>
  25 #include <svx/fontworkbar.hxx>
  26
  27 using vcl::EnumContext;
  28
  29 namespace svx::sidebar
  30 {
  31 EnumContext::Context SelectionAnalyzer::GetContextForSelection_SC(const SdrMarkList& rMarkList)
  32 {
  33     EnumContext::Context eContext = EnumContext::Context::Unknown;
  34
  35     switch (rMarkList.GetMarkCount())
  36     {
  37         case 0:
  38             // Empty selection.  Return Context::Unknown to let the caller
  39             // substitute it with the default context.
  40             break;
  41
  42         case 1:
  43         {
  44             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
  45             auto pTextObj = DynCastSdrTextObj(pObj);
  46             if (pTextObj && pTextObj->IsInEditMode())
  47             {
  48                 eContext = EnumContext::Context::DrawText;
  49             }
  50             else if (svx::checkForFontWork(pObj))
  51             {
  52                 eContext = EnumContext::Context::DrawFontwork;
  53             }
  54             else
  55             {
  56                 const SdrInventor nInv = pObj->GetObjInventor();
  57                 const SdrObjKind nObjId = pObj->GetObjIdentifier();
  58                 if (nInv == SdrInventor::Default)
  59                     eContext = GetContextForObjectId_SC(nObjId);
  60                 else if (nInv == SdrInventor::FmForm)
  61                     eContext = EnumContext::Context::Form;
  62             }
  63             break;
  64         }
  65
  66         default:
  67         {
  68             // Multi selection.
  69             switch (GetInventorTypeFromMark(rMarkList))
  70             {
  71                 case SdrInventor::Default:
  72                 {
  73                     const SdrObjKind nObjId(GetObjectTypeFromMark(rMarkList));
  74                     if (nObjId == SdrObjKind::NONE)
  75                         eContext = EnumContext::Context::MultiObject;
  76                     else
  77                         eContext = GetContextForObjectId_SC(nObjId);
  78                     break;
  79                 }
  80
  81                 case SdrInventor::FmForm:
  82                     eContext = EnumContext::Context::Form;
  83                     break;
  84
  85                 case SdrInventor::Unknown:
  86                     eContext = EnumContext::Context::MultiObject;
  87                     break;
  88
  89                 default:
  90                     break;
  91             }
  92         }
  93     }
  94
  95     return eContext;
  96 }
  97
  98 EnumContext::Context SelectionAnalyzer::GetContextForSelection_SD(const SdrMarkList& rMarkList,
  99                                                                   const ViewType eViewType)
 100 {
 101     EnumContext::Context eContext = EnumContext::Context::Unknown;
 102
 103     // Note that some cases are handled by the caller.  They rely on
 104     // sd specific data.
 105     switch (rMarkList.GetMarkCount())
 106     {
 107         case 0:
 108             switch (eViewType)
 109             {
 110                 case ViewType::Standard:
 111                     eContext = EnumContext::Context::DrawPage;
 112                     break;
 113                 case ViewType::Master:
 114                     eContext = EnumContext::Context::MasterPage;
 115                     break;
 116                 case ViewType::Handout:
 117                     eContext = EnumContext::Context::HandoutPage;
 118                     break;
 119                 case ViewType::Notes:
 120                     eContext = EnumContext::Context::NotesPage;
 121                     break;
 122             }
 123             break;
 124
 125         case 1:
 126         {
 127             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 128             auto pTextObj = DynCastSdrTextObj(pObj);
 129             if (pTextObj && pTextObj->IsInEditMode())
 130             {
 131                 if (pObj->GetObjIdentifier() == SdrObjKind::Table)
 132                 {
 133                     // Let a table object take precedence over text
 134                     // edit mode.  The panels for text editing are
 135                     // present for table context as well, anyway.
 136                     eContext = EnumContext::Context::Table;
 137                 }
 138                 else
 139                     eContext = EnumContext::Context::DrawText;
 140             }
 141             else if (svx::checkForFontWork(pObj))
 142             {
 143                 eContext = EnumContext::Context::DrawFontwork;
 144             }
 145             else
 146             {
 147                 const SdrInventor nInv = pObj->GetObjInventor();
 148                 SdrObjKind nObjId = pObj->GetObjIdentifier();
 149                 if (nInv == SdrInventor::Default)
 150                 {
 151                     if (nObjId == SdrObjKind::Group)
 152                     {
 153                         nObjId = GetObjectTypeFromGroup(pObj);
 154                         if (nObjId == SdrObjKind::NONE)
 155                             nObjId = SdrObjKind::Group;
 156                     }
 157                     eContext = GetContextForObjectId_SD(nObjId, eViewType);
 158                 }
 159                 else if (nInv == SdrInventor::E3d)
 160                 {
 161                     eContext = EnumContext::Context::ThreeDObject;
 162                 }
 163                 else if (nInv == SdrInventor::FmForm)
 164                 {
 165                     eContext = EnumContext::Context::Form;
 166                 }
 167             }
 168             break;
 169         }
 170
 171         default:
 172         {
 173             switch (GetInventorTypeFromMark(rMarkList))
 174             {
 175                 case SdrInventor::Default:
 176                 {
 177                     const SdrObjKind nObjId = GetObjectTypeFromMark(rMarkList);
 178                     if (nObjId == SdrObjKind::NONE)
 179                         eContext = EnumContext::Context::MultiObject;
 180                     else
 181                         eContext = GetContextForObjectId_SD(nObjId, eViewType);
 182                     break;
 183                 }
 184
 185                 case SdrInventor::E3d:
 186                     eContext = EnumContext::Context::ThreeDObject;
 187                     break;
 188
 189                 case SdrInventor::FmForm:
 190                     eContext = EnumContext::Context::Form;
 191                     break;
 192
 193                 case SdrInventor::Unknown:
 194                     eContext = EnumContext::Context::MultiObject;
 195                     break;
 196
 197                 default:
 198                     break;
 199             }
 200             break;
 201         }
 202     }
 203
 204     return eContext;
 205 }
 206
 207 EnumContext::Context SelectionAnalyzer::GetContextForObjectId_SC(const SdrObjKind nObjectId)
 208 {
 209     switch (nObjectId)
 210     {
 211         case SdrObjKind::Caption:
 212         case SdrObjKind::TitleText:
 213         case SdrObjKind::OutlineText:
 214         case SdrObjKind::Text:
 215         case SdrObjKind::Measure:
 216         case SdrObjKind::Rectangle:
 217         case SdrObjKind::CircleOrEllipse:
 218         case SdrObjKind::FreehandFill:
 219         case SdrObjKind::PathFill:
 220         case SdrObjKind::Polygon:
 221         case SdrObjKind::CircleSection:
 222         case SdrObjKind::CircleArc:
 223         case SdrObjKind::CircleCut:
 224         case SdrObjKind::CustomShape:
 225         case SdrObjKind::Group:
 226             return EnumContext::Context::Draw;
 227
 228         case SdrObjKind::PolyLine:
 229         case SdrObjKind::PathLine:
 230         case SdrObjKind::FreehandLine:
 231         case SdrObjKind::Line:
 232         case SdrObjKind::Edge:
 233             return EnumContext::Context::DrawLine;
 234
 235         case SdrObjKind::Graphic:
 236             return EnumContext::Context::Graphic;
 237
 238         case SdrObjKind::OLE2:
 239             return EnumContext::Context::OLE;
 240
 241         case SdrObjKind::Media:
 242             return EnumContext::Context::Media;
 243
 244         default:
 245             return EnumContext::Context::Unknown;
 246     }
 247 }
 248
 249 EnumContext::Context SelectionAnalyzer::GetContextForObjectId_SD(const SdrObjKind nObjectId,
 250                                                                  const ViewType eViewType)
 251 {
 252     switch (nObjectId)
 253     {
 254         case SdrObjKind::Caption:
 255         case SdrObjKind::Measure:
 256         case SdrObjKind::Rectangle:
 257         case SdrObjKind::CircleOrEllipse:
 258         case SdrObjKind::FreehandFill:
 259         case SdrObjKind::PathFill:
 260         case SdrObjKind::Polygon:
 261         case SdrObjKind::CircleSection:
 262         case SdrObjKind::CircleArc:
 263         case SdrObjKind::CircleCut:
 264         case SdrObjKind::CustomShape:
 265         case SdrObjKind::Group:
 266             return EnumContext::Context::Draw;
 267
 268         case SdrObjKind::Edge:
 269         case SdrObjKind::PathLine:
 270         case SdrObjKind::FreehandLine:
 271         case SdrObjKind::PolyLine:
 272         case SdrObjKind::Line:
 273             return EnumContext::Context::DrawLine;
 274
 275         case SdrObjKind::TitleText:
 276         case SdrObjKind::OutlineText:
 277         case SdrObjKind::Text:
 278             return EnumContext::Context::TextObject;
 279
 280         case SdrObjKind::Graphic:
 281             return EnumContext::Context::Graphic;
 282
 283         case SdrObjKind::OLE2:
 284             return EnumContext::Context::OLE;
 285
 286         case SdrObjKind::Media:
 287             return EnumContext::Context::Media;
 288
 289         case SdrObjKind::Table:
 290             return EnumContext::Context::Table;
 291
 292         case SdrObjKind::Page:
 293             switch (eViewType)
 294             {
 295                 case ViewType::Handout:
 296                     return EnumContext::Context::HandoutPage;
 297                 case ViewType::Notes:
 298                     return EnumContext::Context::NotesPage;
 299                 default:
 300                     return EnumContext::Context::Unknown;
 301             }
 302
 303         default:
 304             return EnumContext::Context::Unknown;
 305     }
 306 }
 307
 308 SdrInventor SelectionAnalyzer::GetInventorTypeFromMark(const SdrMarkList& rMarkList)
 309 {
 310     const size_t nMarkCount(rMarkList.GetMarkCount());
 311
 312     if (nMarkCount < 1)
 313         return SdrInventor::Unknown;
 314
 315     SdrMark* pMark = rMarkList.GetMark(0);
 316     SdrObject* pObj = pMark->GetMarkedSdrObj();
 317     const SdrInventor nFirstInv = pObj->GetObjInventor();
 318
 319     for (size_t nIndex = 1; nIndex < nMarkCount; ++nIndex)
 320     {
 321         pMark = rMarkList.GetMark(nIndex);
 322         pObj = pMark->GetMarkedSdrObj();
 323         const SdrInventor nInv(pObj->GetObjInventor());
 324
 325         if (nInv != nFirstInv)
 326             return SdrInventor::Unknown;
 327     }
 328
 329     return nFirstInv;
 330 }
 331
 332 SdrObjKind SelectionAnalyzer::GetObjectTypeFromGroup(const SdrObject* pObj)
 333 {
 334     SdrObjList* pObjList = pObj->GetSubList();
 335     if (pObjList)
 336     {
 337         const size_t nSubObjCount(pObjList->GetObjCount());
 338
 339         if (nSubObjCount > 0)
 340         {
 341             SdrObject* pSubObj = pObjList->GetObj(0);
 342             SdrObjKind nResultType = pSubObj->GetObjIdentifier();
 343
 344             if (nResultType == SdrObjKind::Group)
 345                 nResultType = GetObjectTypeFromGroup(pSubObj);
 346
 347             if (IsShapeType(nResultType))
 348                 nResultType = SdrObjKind::CustomShape;
 349
 350             if (IsTextObjType(nResultType))
 351                 nResultType = SdrObjKind::Text;
 352
 353             for (size_t nIndex = 1; nIndex < nSubObjCount; ++nIndex)
 354             {
 355                 pSubObj = pObjList->GetObj(nIndex);
 356                 SdrObjKind nType(pSubObj->GetObjIdentifier());
 357
 358                 if (nType == SdrObjKind::Group)
 359                     nType = GetObjectTypeFromGroup(pSubObj);
 360
 361                 if (IsShapeType(nType))
 362                     nType = SdrObjKind::CustomShape;
 363
 364                 if ((nType == SdrObjKind::CustomShape) && (nResultType == SdrObjKind::Text))
 365                     nType = SdrObjKind::Text;
 366
 367                 if (IsTextObjType(nType))
 368                     nType = SdrObjKind::Text;
 369
 370                 if ((nType == SdrObjKind::Text) && (nResultType == SdrObjKind::CustomShape))
 371                     nResultType = SdrObjKind::Text;
 372
 373                 if (nType != nResultType)
 374                     return SdrObjKind::NONE;
 375             }
 376
 377             return nResultType;
 378         }
 379     }
 380
 381     return SdrObjKind::NONE;
 382 }
 383
 384 SdrObjKind SelectionAnalyzer::GetObjectTypeFromMark(const SdrMarkList& rMarkList)
 385 {
 386     const size_t nMarkCount(rMarkList.GetMarkCount());
 387
 388     if (nMarkCount < 1)
 389         return SdrObjKind::NONE;
 390
 391     SdrMark* pMark = rMarkList.GetMark(0);
 392     SdrObject* pObj = pMark->GetMarkedSdrObj();
 393     SdrObjKind nResultType = pObj->GetObjIdentifier();
 394
 395     if (nResultType == SdrObjKind::Group)
 396         nResultType = GetObjectTypeFromGroup(pObj);
 397
 398     if (IsShapeType(nResultType))
 399         nResultType = SdrObjKind::CustomShape;
 400
 401     if (IsTextObjType(nResultType))
 402         nResultType = SdrObjKind::Text;
 403
 404     for (size_t nIndex = 1; nIndex < nMarkCount; ++nIndex)
 405     {
 406         pMark = rMarkList.GetMark(nIndex);
 407         pObj = pMark->GetMarkedSdrObj();
 408         SdrObjKind nType = pObj->GetObjIdentifier();
 409
 410         if (nType == SdrObjKind::Group)
 411             nType = GetObjectTypeFromGroup(pObj);
 412
 413         if (IsShapeType(nType))
 414             nType = SdrObjKind::CustomShape;
 415
 416         if ((nType == SdrObjKind::CustomShape) && (nResultType == SdrObjKind::Text))
 417             nType = SdrObjKind::Text;
 418
 419         if (IsTextObjType(nType))
 420             nType = SdrObjKind::Text;
 421
 422         if ((nType == SdrObjKind::Text) && (nResultType == SdrObjKind::CustomShape))
 423             nResultType = SdrObjKind::Text;
 424
 425         if (nType != nResultType)
 426             return SdrObjKind::NONE;
 427     }
 428
 429     return nResultType;
 430 }
 431
 432 bool SelectionAnalyzer::IsShapeType(const SdrObjKind nType)
 433 {
 434     switch (nType)
 435     {
 436         case SdrObjKind::Line:
 437         case SdrObjKind::CircleArc:
 438         case SdrObjKind::PolyLine:
 439         case SdrObjKind::PathLine:
 440         case SdrObjKind::Rectangle:
 441         case SdrObjKind::CircleOrEllipse:
 442         case SdrObjKind::CircleSection:
 443         case SdrObjKind::CircleCut:
 444         case SdrObjKind::PathFill:
 445         case SdrObjKind::CustomShape:
 446         case SdrObjKind::Caption:
 447         case SdrObjKind::Measure:
 448         case SdrObjKind::Edge:
 449         case SdrObjKind::Polygon:
 450         case SdrObjKind::FreehandLine:
 451         case SdrObjKind::FreehandFill:
 452
 453         // #122145# adding SdrObjKind::OLE2 since these also allow line/fill style and may
 454         // be multiselected/grouped with normal draw objects, e.g. math OLE objects
 455         case SdrObjKind::OLE2:
 456             return true;
 457
 458         default:
 459             return false;
 460     }
 461 }
 462
 463 bool SelectionAnalyzer::IsTextObjType(const SdrObjKind nType)
 464 {
 465     switch (nType)
 466     {
 467         case SdrObjKind::Text:
 468         case SdrObjKind::TitleText:
 469         case SdrObjKind::OutlineText:
 470             return true;
 471
 472         default:
 473             return false;
 474     }
 475 }
 476
 477 } // end of namespace svx::sidebar
 478
 479 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */