svx/source/sidebar/SelectionAnalyzer.cxx

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   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 "svx/sidebar/SelectionAnalyzer.hxx"
  20 #include "svx/svdmrkv.hxx"
  21 #include "svx/svdobj.hxx"
  22 #include "svx/svdotext.hxx"
  23 #include "svx/svdpage.hxx"
  24 #include "svx/fmglob.hxx"
  25 #include "svx/globl3d.hxx"
  26
  27 using sfx2::sidebar::EnumContext;
  28
  29
  30 namespace svx { namespace sidebar {
  31
  32 EnumContext::Context SelectionAnalyzer::GetContextForSelection_SC (const SdrMarkList& rMarkList)
  33 {
  34     EnumContext::Context eContext = EnumContext::Context_Unknown;
  35
  36     switch (rMarkList.GetMarkCount())
  37     {
  38         case 0:
  39             // Empty selection.  Return Context_Unknown to let the caller
  40             // substitute it with the default context.
  41             break;
  42
  43         case 1:
  44         {
  45             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
  46             if ( pObj->ISA(SdrTextObj) && ((SdrTextObj*)pObj)->IsInEditMode() )
  47             {
  48                 eContext = EnumContext::Context_DrawText;
  49             }
  50             else
  51             {
  52                 const sal_uInt32 nInv = pObj->GetObjInventor();
  53                 const sal_uInt16 nObjId = pObj->GetObjIdentifier();
  54                 if (nInv == SdrInventor)
  55                     eContext = GetContextForObjectId_SC(nObjId);
  56                 else if (nInv == FmFormInventor)
  57                     eContext = EnumContext::Context_Form;
  58             }
  59             break;
  60         }
  61
  62         default:
  63         {
  64             // Multi selection.
  65             switch (GetInventorTypeFromMark(rMarkList))
  66             {
  67                 case SdrInventor:
  68                 {
  69                     const sal_uInt16 nObjId (GetObjectTypeFromMark(rMarkList));
  70                     if (nObjId == 0)
  71                         eContext = EnumContext::Context_MultiObject;
  72                     else
  73                         eContext = GetContextForObjectId_SC(nObjId);
  74                     break;
  75                 }
  76
  77                 case FmFormInventor:
  78                     eContext = EnumContext::Context_Form;
  79                     break;
  80
  81                 case 0:
  82                     eContext = EnumContext::Context_MultiObject;
  83                     break;
  84             }
  85         }
  86     }
  87
  88     return eContext;
  89 }
  90
  91
  92
  93
  94 EnumContext::Context SelectionAnalyzer::GetContextForSelection_SD (
  95     const SdrMarkList& rMarkList,
  96     const ViewType eViewType)
  97 {
  98     EnumContext::Context eContext = EnumContext::Context_Unknown;
  99
 100     // Note that some cases are handled by the caller.  They rely on
 101     // sd specific data.
 102     switch (rMarkList.GetMarkCount())
 103     {
 104         case 0:
 105             switch(eViewType)
 106             {
 107                 case VT_Standard:
 108                     eContext = EnumContext::Context_DrawPage;
 109                     break;
 110                 case VT_Master:
 111                     eContext = EnumContext::Context_MasterPage;
 112                     break;
 113                 case VT_Handout:
 114                     eContext = EnumContext::Context_HandoutPage;
 115                     break;
 116                 case VT_Notes:
 117                     eContext = EnumContext::Context_NotesPage;
 118                     break;
 119                 case VT_Outline:
 120                     eContext = EnumContext::Context_OutlineText;
 121                     break;
 122             }
 123             break;
 124
 125         case 1:
 126         {
 127             SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
 128             if (pObj->ISA(SdrTextObj) && ((SdrTextObj*)pObj)->IsInEditMode())
 129             {
 130                 if (pObj->GetObjIdentifier() == OBJ_TABLE)
 131                 {
 132                     // Let a table object take precedence over text
 133                     // edit mode.  The panels for text editing are
 134                     // present for table context as well, anyway.
 135                     eContext = EnumContext::Context_Table;
 136                 }
 137                 else
 138                     eContext = EnumContext::Context_DrawText;
 139             }
 140             else
 141             {
 142                 const sal_uInt32 nInv = pObj->GetObjInventor();
 143                 sal_uInt16 nObjId = pObj->GetObjIdentifier();
 144                 if (nInv == SdrInventor)
 145                 {
 146                     if (nObjId == OBJ_GRUP)
 147                     {
 148                         nObjId = GetObjectTypeFromGroup(pObj);
 149                         if (nObjId == 0)
 150                             nObjId = OBJ_GRUP;
 151                     }
 152                     eContext = GetContextForObjectId_SD(nObjId, eViewType);
 153                 }
 154                 else if (nInv == E3dInventor)
 155                 {
 156                     eContext = EnumContext::Context_3DObject;
 157                 }
 158                 else if (nInv == FmFormInventor)
 159                 {
 160                     eContext = EnumContext::Context_Form;
 161                 }
 162             }
 163             break;
 164         }
 165
 166         default:
 167         {
 168             switch (GetInventorTypeFromMark(rMarkList))
 169             {
 170                 case SdrInventor:
 171                 {
 172                     const sal_uInt16 nObjId = GetObjectTypeFromMark(rMarkList);
 173                     if (nObjId == 0)
 174                         eContext = EnumContext::Context_MultiObject;
 175                     else
 176                         eContext = GetContextForObjectId_SD(nObjId, eViewType);
 177                     break;
 178                 }
 179
 180                 case E3dInventor:
 181                     eContext = EnumContext::Context_3DObject;
 182                     break;
 183
 184                 case FmFormInventor:
 185                     eContext = EnumContext::Context_Form;
 186                     break;
 187
 188                 case 0:
 189                     eContext = EnumContext::Context_MultiObject;
 190                     break;
 191             }
 192             break;
 193         }
 194     }
 195
 196     return eContext;
 197 }
 198
 199
 200
 201
 202 EnumContext::Context SelectionAnalyzer::GetContextForObjectId_SC (const sal_uInt16 nObjectId)
 203 {
 204     switch (nObjectId)
 205     {
 206         case OBJ_CAPTION:
 207         case OBJ_TITLETEXT:
 208         case OBJ_OUTLINETEXT:
 209         case OBJ_TEXT:
 210         case OBJ_TEXTEXT:
 211         case OBJ_PATHLINE:
 212         case OBJ_PLIN:
 213         case OBJ_FREELINE:
 214         case OBJ_EDGE:
 215         case OBJ_LINE:
 216         case OBJ_MEASURE:
 217         case OBJ_RECT:
 218         case OBJ_CIRC:
 219         case OBJ_FREEFILL:
 220         case OBJ_PATHFILL:
 221         case OBJ_POLY:
 222         case OBJ_SECT:
 223         case OBJ_CARC:
 224         case OBJ_CCUT:
 225         case OBJ_CUSTOMSHAPE:
 226         case OBJ_GRUP:
 227             return EnumContext::Context_Draw;
 228
 229         case OBJ_GRAF:
 230             return EnumContext::Context_Graphic;
 231
 232         case OBJ_OLE2:
 233             return EnumContext::Context_OLE;
 234
 235         case OBJ_MEDIA:
 236             return EnumContext::Context_Media;
 237             break;
 238
 239         default:
 240             return EnumContext::Context_Unknown;
 241     }
 242 }
 243
 244
 245
 246
 247 EnumContext::Context SelectionAnalyzer::GetContextForObjectId_SD (
 248     const sal_uInt16 nObjectId,
 249     const ViewType eViewType)
 250 {
 251     switch (nObjectId)
 252     {
 253         case OBJ_CAPTION:
 254         case OBJ_PATHLINE:
 255         case OBJ_PLIN:
 256         case OBJ_FREELINE:
 257         case OBJ_EDGE:
 258         case OBJ_LINE:
 259         case OBJ_MEASURE:
 260         case OBJ_RECT:
 261         case OBJ_CIRC:
 262         case OBJ_FREEFILL:
 263         case OBJ_PATHFILL:
 264         case OBJ_POLY:
 265         case OBJ_SECT:
 266         case OBJ_CARC:
 267         case OBJ_CCUT:
 268         case OBJ_CUSTOMSHAPE:
 269         case OBJ_GRUP:
 270             return EnumContext::Context_Draw;
 271
 272         case OBJ_TITLETEXT:
 273         case OBJ_OUTLINETEXT:
 274         case OBJ_TEXT:
 275         case OBJ_TEXTEXT:
 276             return EnumContext::Context_TextObject;
 277
 278         case OBJ_GRAF:
 279             return EnumContext::Context_Graphic;
 280
 281         case OBJ_OLE2:
 282             return EnumContext::Context_OLE;
 283
 284         case OBJ_MEDIA:
 285             return EnumContext::Context_Media;
 286
 287         case OBJ_TABLE:
 288             return EnumContext::Context_Table;
 289
 290         case OBJ_PAGE:
 291             switch (eViewType)
 292             {
 293                 case VT_Handout:
 294                     return EnumContext::Context_HandoutPage;
 295                 case VT_Notes:
 296                     return EnumContext::Context_NotesPage;
 297                 case VT_Outline:
 298                     return EnumContext::Context_OutlineText;
 299                 default:
 300                     return EnumContext::Context_Unknown;
 301             }
 302
 303         default:
 304             return EnumContext::Context_Unknown;
 305     }
 306 }
 307
 308
 309
 310
 311 sal_uInt32 SelectionAnalyzer::GetInventorTypeFromMark (const SdrMarkList& rMarkList)
 312 {
 313     const sal_uLong nMarkCount (rMarkList.GetMarkCount());
 314
 315     if (nMarkCount < 1)
 316         return 0;
 317
 318     SdrMark* pMark = rMarkList.GetMark(0);
 319     SdrObject* pObj = pMark->GetMarkedSdrObj();
 320     const sal_uInt32 nFirstInv = pObj->GetObjInventor();
 321
 322     for (sal_uLong nIndex=1; nIndex<nMarkCount; ++nIndex)
 323     {
 324         pMark = rMarkList.GetMark(nIndex);
 325         pObj = pMark->GetMarkedSdrObj();
 326         const sal_uInt32 nInv (pObj->GetObjInventor());
 327
 328         if (nInv != nFirstInv)
 329             return 0;
 330     }
 331
 332     return nFirstInv;
 333 }
 334
 335
 336
 337
 338 sal_uInt16 SelectionAnalyzer::GetObjectTypeFromGroup (const SdrObject* pObj)
 339 {
 340     SdrObjList* pObjList = pObj->GetSubList();
 341     if (pObjList)
 342     {
 343         const sal_uLong nSubObjCount (pObjList->GetObjCount());
 344
 345         if (nSubObjCount>0)
 346         {
 347             SdrObject* pSubObj = pObjList->GetObj(0);
 348             sal_uInt16 nResultType = pSubObj->GetObjIdentifier();
 349
 350             if (nResultType == OBJ_GRUP)
 351                 nResultType = GetObjectTypeFromGroup(pSubObj);
 352
 353             if (IsShapeType(nResultType))
 354                 nResultType = OBJ_CUSTOMSHAPE;
 355
 356             if (IsTextObjType(nResultType))
 357                 nResultType = OBJ_TEXT;
 358
 359             for (sal_uInt16 nIndex=1; nIndex<nSubObjCount; ++nIndex)
 360             {
 361                 pSubObj = pObjList->GetObj(nIndex);
 362                 sal_uInt16 nType (pSubObj->GetObjIdentifier());
 363
 364                 if(nType == OBJ_GRUP)
 365                     nType = GetObjectTypeFromGroup(pSubObj);
 366
 367                 if (IsShapeType(nType))
 368                     nType = OBJ_CUSTOMSHAPE;
 369
 370                 if ((nType == OBJ_CUSTOMSHAPE) && (nResultType == OBJ_TEXT))
 371                     nType = OBJ_TEXT;
 372
 373                 if (IsTextObjType(nType))
 374                     nType = OBJ_TEXT;
 375
 376                 if ((nType == OBJ_TEXT) && (nResultType == OBJ_CUSTOMSHAPE))
 377                     nResultType = OBJ_TEXT;
 378
 379                 if (nType != nResultType)
 380                     return 0;
 381             }
 382
 383             return nResultType;
 384         }
 385     }
 386
 387     return 0;
 388 }
 389
 390
 391
 392
 393 sal_uInt16  SelectionAnalyzer::GetObjectTypeFromMark (const SdrMarkList& rMarkList)
 394 {
 395     const sal_uLong nMarkCount (rMarkList.GetMarkCount());
 396
 397     if (nMarkCount < 1)
 398         return 0;
 399
 400     SdrMark* pMark = rMarkList.GetMark(0);
 401     SdrObject* pObj = pMark->GetMarkedSdrObj();
 402     sal_uInt16 nResultType = pObj->GetObjIdentifier();
 403
 404     if(nResultType == OBJ_GRUP)
 405         nResultType = GetObjectTypeFromGroup(pObj);
 406
 407     if (IsShapeType(nResultType))
 408         nResultType = OBJ_CUSTOMSHAPE;
 409
 410     if (IsTextObjType(nResultType))
 411         nResultType = OBJ_TEXT;
 412
 413     for (sal_uLong nIndex=1; nIndex<nMarkCount; ++nIndex)
 414     {
 415         pMark = rMarkList.GetMark(nIndex);
 416         pObj = pMark->GetMarkedSdrObj();
 417         sal_uInt16 nType = pObj->GetObjIdentifier();
 418
 419         if(nType == OBJ_GRUP)
 420             nType = GetObjectTypeFromGroup(pObj);
 421
 422         if (IsShapeType(nType))
 423             nType = OBJ_CUSTOMSHAPE;
 424
 425         if ((nType == OBJ_CUSTOMSHAPE) && (nResultType == OBJ_TEXT))
 426             nType = OBJ_TEXT;
 427
 428         if (IsTextObjType(nType))
 429             nType = OBJ_TEXT;
 430
 431         if ((nType == OBJ_TEXT) && (nResultType == OBJ_CUSTOMSHAPE))
 432             nResultType = OBJ_TEXT;
 433
 434         if (nType != nResultType)
 435             return 0;
 436     }
 437
 438     return nResultType;
 439 }
 440
 441
 442
 443
 444 bool SelectionAnalyzer::IsShapeType (const sal_uInt16 nType)
 445 {
 446     switch (nType)
 447     {
 448         case OBJ_LINE:
 449         case OBJ_CARC:
 450         case OBJ_PLIN:
 451         case OBJ_PATHLINE:
 452         case OBJ_RECT:
 453         case OBJ_CIRC:
 454         case OBJ_SECT:
 455         case OBJ_CCUT:
 456         case OBJ_PATHFILL:
 457         case OBJ_CUSTOMSHAPE:
 458         case OBJ_CAPTION:
 459         case OBJ_MEASURE:
 460         case OBJ_EDGE:
 461         case OBJ_POLY:
 462         case OBJ_FREELINE:
 463         case OBJ_FREEFILL:
 464
 465         // #122145# adding OBJ_OLE2 since these also allow line/fill style and may
 466         // be multiselected/grouped with normal draw objects, e.g. math OLE objects
 467         case OBJ_OLE2:
 468             return true;
 469
 470         default:
 471             return false;
 472     }
 473 }
 474
 475
 476
 477
 478 bool SelectionAnalyzer::IsTextObjType (const sal_uInt16 nType)
 479 {
 480     switch(nType)
 481     {
 482         case OBJ_TEXT:
 483         case OBJ_TEXTEXT:
 484         case OBJ_TITLETEXT:
 485         case OBJ_OUTLINETEXT:
 486             return true;
 487
 488         default:
 489             return false;
 490     }
 491 }
 492
 493
 494
 495 } } // end of namespace ::svx::sidebar