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 = dynamic_cast<SdrTextObj*>(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 sal_uInt16 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 sal_uInt16 nObjId(GetObjectTypeFromMark(rMarkList));
  74                     if (nObjId == 0)
  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 = dynamic_cast<SdrTextObj*>(pObj);
 129             if (pTextObj && pTextObj->IsInEditMode())
 130             {
 131                 if (pObj->GetObjIdentifier() == OBJ_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                 sal_uInt16 nObjId = pObj->GetObjIdentifier();
 149                 if (nInv == SdrInventor::Default)
 150                 {
 151                     if (nObjId == OBJ_GRUP)
 152                     {
 153                         nObjId = GetObjectTypeFromGroup(pObj);
 154                         if (nObjId == 0)
 155                             nObjId = OBJ_GRUP;
 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 sal_uInt16 nObjId = GetObjectTypeFromMark(rMarkList);
 178                     if (nObjId == 0)
 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 sal_uInt16 nObjectId)
 208 {
 209     switch (nObjectId)
 210     {
 211         case OBJ_CAPTION:
 212         case OBJ_TITLETEXT:
 213         case OBJ_OUTLINETEXT:
 214         case OBJ_TEXT:
 215         case OBJ_MEASURE:
 216         case OBJ_RECT:
 217         case OBJ_CIRC:
 218         case OBJ_FREEFILL:
 219         case OBJ_PATHFILL:
 220         case OBJ_POLY:
 221         case OBJ_SECT:
 222         case OBJ_CARC:
 223         case OBJ_CCUT:
 224         case OBJ_CUSTOMSHAPE:
 225         case OBJ_GRUP:
 226             return EnumContext::Context::Draw;
 227
 228         case OBJ_PLIN:
 229         case OBJ_PATHLINE:
 230         case OBJ_FREELINE:
 231         case OBJ_LINE:
 232         case OBJ_EDGE:
 233             return EnumContext::Context::DrawLine;
 234
 235         case OBJ_GRAF:
 236             return EnumContext::Context::Graphic;
 237
 238         case OBJ_OLE2:
 239             return EnumContext::Context::OLE;
 240
 241         case OBJ_MEDIA:
 242             return EnumContext::Context::Media;
 243
 244         default:
 245             return EnumContext::Context::Unknown;
 246     }
 247 }
 248
 249 EnumContext::Context SelectionAnalyzer::GetContextForObjectId_SD(const sal_uInt16 nObjectId,
 250                                                                  const ViewType eViewType)
 251 {
 252     switch (nObjectId)
 253     {
 254         case OBJ_CAPTION:
 255         case OBJ_MEASURE:
 256         case OBJ_RECT:
 257         case OBJ_CIRC:
 258         case OBJ_FREEFILL:
 259         case OBJ_PATHFILL:
 260         case OBJ_POLY:
 261         case OBJ_SECT:
 262         case OBJ_CARC:
 263         case OBJ_CCUT:
 264         case OBJ_CUSTOMSHAPE:
 265         case OBJ_GRUP:
 266             return EnumContext::Context::Draw;
 267
 268         case OBJ_EDGE:
 269         case OBJ_PATHLINE:
 270         case OBJ_FREELINE:
 271         case OBJ_PLIN:
 272         case OBJ_LINE:
 273             return EnumContext::Context::DrawLine;
 274
 275         case OBJ_TITLETEXT:
 276         case OBJ_OUTLINETEXT:
 277         case OBJ_TEXT:
 278             return EnumContext::Context::TextObject;
 279
 280         case OBJ_GRAF:
 281             return EnumContext::Context::Graphic;
 282
 283         case OBJ_OLE2:
 284             return EnumContext::Context::OLE;
 285
 286         case OBJ_MEDIA:
 287             return EnumContext::Context::Media;
 288
 289         case OBJ_TABLE:
 290             return EnumContext::Context::Table;
 291
 292         case OBJ_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 sal_uInt16 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             sal_uInt16 nResultType = pSubObj->GetObjIdentifier();
 343
 344             if (nResultType == OBJ_GRUP)
 345                 nResultType = GetObjectTypeFromGroup(pSubObj);
 346
 347             if (IsShapeType(nResultType))
 348                 nResultType = OBJ_CUSTOMSHAPE;
 349
 350             if (IsTextObjType(nResultType))
 351                 nResultType = OBJ_TEXT;
 352
 353             for (size_t nIndex = 1; nIndex < nSubObjCount; ++nIndex)
 354             {
 355                 pSubObj = pObjList->GetObj(nIndex);
 356                 sal_uInt16 nType(pSubObj->GetObjIdentifier());
 357
 358                 if (nType == OBJ_GRUP)
 359                     nType = GetObjectTypeFromGroup(pSubObj);
 360
 361                 if (IsShapeType(nType))
 362                     nType = OBJ_CUSTOMSHAPE;
 363
 364                 if ((nType == OBJ_CUSTOMSHAPE) && (nResultType == OBJ_TEXT))
 365                     nType = OBJ_TEXT;
 366
 367                 if (IsTextObjType(nType))
 368                     nType = OBJ_TEXT;
 369
 370                 if ((nType == OBJ_TEXT) && (nResultType == OBJ_CUSTOMSHAPE))
 371                     nResultType = OBJ_TEXT;
 372
 373                 if (nType != nResultType)
 374                     return 0;
 375             }
 376
 377             return nResultType;
 378         }
 379     }
 380
 381     return 0;
 382 }
 383
 384 sal_uInt16 SelectionAnalyzer::GetObjectTypeFromMark(const SdrMarkList& rMarkList)
 385 {
 386     const size_t nMarkCount(rMarkList.GetMarkCount());
 387
 388     if (nMarkCount < 1)
 389         return 0;
 390
 391     SdrMark* pMark = rMarkList.GetMark(0);
 392     SdrObject* pObj = pMark->GetMarkedSdrObj();
 393     sal_uInt16 nResultType = pObj->GetObjIdentifier();
 394
 395     if (nResultType == OBJ_GRUP)
 396         nResultType = GetObjectTypeFromGroup(pObj);
 397
 398     if (IsShapeType(nResultType))
 399         nResultType = OBJ_CUSTOMSHAPE;
 400
 401     if (IsTextObjType(nResultType))
 402         nResultType = OBJ_TEXT;
 403
 404     for (size_t nIndex = 1; nIndex < nMarkCount; ++nIndex)
 405     {
 406         pMark = rMarkList.GetMark(nIndex);
 407         pObj = pMark->GetMarkedSdrObj();
 408         sal_uInt16 nType = pObj->GetObjIdentifier();
 409
 410         if (nType == OBJ_GRUP)
 411             nType = GetObjectTypeFromGroup(pObj);
 412
 413         if (IsShapeType(nType))
 414             nType = OBJ_CUSTOMSHAPE;
 415
 416         if ((nType == OBJ_CUSTOMSHAPE) && (nResultType == OBJ_TEXT))
 417             nType = OBJ_TEXT;
 418
 419         if (IsTextObjType(nType))
 420             nType = OBJ_TEXT;
 421
 422         if ((nType == OBJ_TEXT) && (nResultType == OBJ_CUSTOMSHAPE))
 423             nResultType = OBJ_TEXT;
 424
 425         if (nType != nResultType)
 426             return 0;
 427     }
 428
 429     return nResultType;
 430 }
 431
 432 bool SelectionAnalyzer::IsShapeType(const sal_uInt16 nType)
 433 {
 434     switch (nType)
 435     {
 436         case OBJ_LINE:
 437         case OBJ_CARC:
 438         case OBJ_PLIN:
 439         case OBJ_PATHLINE:
 440         case OBJ_RECT:
 441         case OBJ_CIRC:
 442         case OBJ_SECT:
 443         case OBJ_CCUT:
 444         case OBJ_PATHFILL:
 445         case OBJ_CUSTOMSHAPE:
 446         case OBJ_CAPTION:
 447         case OBJ_MEASURE:
 448         case OBJ_EDGE:
 449         case OBJ_POLY:
 450         case OBJ_FREELINE:
 451         case OBJ_FREEFILL:
 452
 453         // #122145# adding OBJ_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 OBJ_OLE2:
 456             return true;
 457
 458         default:
 459             return false;
 460     }
 461 }
 462
 463 bool SelectionAnalyzer::IsTextObjType(const sal_uInt16 nType)
 464 {
 465     switch (nType)
 466     {
 467         case OBJ_TEXT:
 468         case OBJ_TITLETEXT:
 469         case OBJ_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: */