svx/source/sdr/primitive2d/sdrattributecreator.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: sdrattributecreator.cxx,v $
  10  *
  11  * $Revision: 1.2.18.1 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 #include "precompiled_svx.hxx"
  33 #include <svx/sdr/primitive2d/sdrattributecreator.hxx>
  34 #include <svtools/itemset.hxx>
  35 #include <svx/xdef.hxx>
  36 #include <basegfx/polygon/b2dpolygon.hxx>
  37 #include <svx/xlineit0.hxx>
  38 #include <svx/xfillit0.hxx>
  39 #include <svx/xlntrit.hxx>
  40 #include <svx/xlnwtit.hxx>
  41 #include <xlinjoit.hxx>
  42 #include <svx/xlnclit.hxx>
  43 #include <svx/xlnstwit.hxx>
  44 #include <svx/xlnedwit.hxx>
  45 #include <svx/xlnstit.hxx>
  46 #include <svx/xlnstcit.hxx>
  47 #include <svx/xlnedit.hxx>
  48 #include <svx/xlnedcit.hxx>
  49 #include <svx/xdash.hxx>
  50 #include <svx/xlndsit.hxx>
  51 #include <svx/xfltrit.hxx>
  52 #include <svx/xflftrit.hxx>
  53 #include <svx/xflclit.hxx>
  54 #include <svx/xgrscit.hxx>
  55 #include <svx/xflhtit.hxx>
  56 #include <svx/xflbckit.hxx>
  57 #include <svx/sdshitm.hxx>
  58 #include <svx/sdsxyitm.hxx>
  59 #include <svx/sdshcitm.hxx>
  60 #include <svx/sdshtitm.hxx>
  61 #include <drawinglayer/attribute/fillattribute.hxx>
  62 #include <drawinglayer/attribute/sdrfillbitmapattribute.hxx>
  63 #include <basegfx/polygon/b2dlinegeometry.hxx>
  64 #include <drawinglayer/attribute/sdrattribute.hxx>
  65 #include <svx/svdotext.hxx>
  66 #include <drawinglayer/attribute/fillbitmapattribute.hxx>
  67 #include <svx/sdr/attribute/sdrtextattribute.hxx>
  68 #include <svx/sdr/attribute/sdrallattribute.hxx>
  69 #include <svx/xbtmpit.hxx>
  70 #include <svtools/itempool.hxx>
  71 #include <vcl/svapp.hxx>
  72 #include <basegfx/range/b2drange.hxx>
  73 #include <svx/svx3ditems.hxx>
  74 #include <com/sun/star/drawing/ProjectionMode.hpp>
  75 #include <com/sun/star/drawing/ShadeMode.hpp>
  76 #include <drawinglayer/attribute/sdrattribute3d.hxx>
  77 #include <drawinglayer/attribute/sdrallattribute3d.hxx>
  78 #include <svx/rectenum.hxx>
  79 #include <svx/sdtfchim.hxx>
  80
  81 //////////////////////////////////////////////////////////////////////////////
  82
  83 namespace drawinglayer
  84 {
  85     namespace
  86     {
  87         attribute::GradientStyle XGradientStyleToGradientStyle(XGradientStyle eStyle)
  88         {
  89             switch(eStyle)
  90             {
  91                 case XGRAD_LINEAR :
  92                 {
  93                     return attribute::GRADIENTSTYLE_LINEAR;
  94                 }
  95                 case XGRAD_AXIAL :
  96                 {
  97                     return attribute::GRADIENTSTYLE_AXIAL;
  98                 }
  99                 case XGRAD_RADIAL :
 100                 {
 101                     return attribute::GRADIENTSTYLE_RADIAL;
 102                 }
 103                 case XGRAD_ELLIPTICAL :
 104                 {
 105                     return attribute::GRADIENTSTYLE_ELLIPTICAL;
 106                 }
 107                 case XGRAD_SQUARE :
 108                 {
 109                     return attribute::GRADIENTSTYLE_SQUARE;
 110                 }
 111                 default :
 112                 {
 113                     return attribute::GRADIENTSTYLE_RECT; // XGRAD_RECT
 114                 }
 115             }
 116         }
 117
 118         attribute::HatchStyle XHatchStyleToHatchStyle(XHatchStyle eStyle)
 119         {
 120             switch(eStyle)
 121             {
 122                 case XHATCH_SINGLE :
 123                 {
 124                     return attribute::HATCHSTYLE_SINGLE;
 125                 }
 126                 case XHATCH_DOUBLE :
 127                 {
 128                     return attribute::HATCHSTYLE_DOUBLE;
 129                 }
 130                 default :
 131                 {
 132                     return attribute::HATCHSTYLE_TRIPLE; // XHATCH_TRIPLE
 133                 }
 134             }
 135         }
 136
 137         basegfx::B2DLineJoin XLineJointtoB2DLineJoin(XLineJoint eLineJoint)
 138         {
 139             switch(eLineJoint)
 140             {
 141                 case XLINEJOINT_MIDDLE :
 142                 {
 143                     return basegfx::B2DLINEJOIN_MIDDLE;
 144                 }
 145                 case XLINEJOINT_BEVEL :
 146                 {
 147                     return basegfx::B2DLINEJOIN_BEVEL;
 148                 }
 149                 case XLINEJOINT_MITER :
 150                 {
 151                     return basegfx::B2DLINEJOIN_MITER;
 152                 }
 153                 case XLINEJOINT_ROUND :
 154                 {
 155                     return basegfx::B2DLINEJOIN_ROUND;
 156                 }
 157                 default :
 158                 {
 159                     return basegfx::B2DLINEJOIN_NONE; // XLINEJOINT_NONE
 160                 }
 161             }
 162         }
 163
 164         basegfx::B2DVector RectPointToB2DVector(RECT_POINT eRectPoint)
 165         {
 166             basegfx::B2DVector aRetval(0.0, 0.0);
 167
 168             // position changes X
 169             switch(eRectPoint)
 170             {
 171                 case RP_LT: case RP_LM: case RP_LB:
 172                 {
 173                     aRetval.setX(-1.0);
 174                     break;
 175                 }
 176
 177                 case RP_RT: case RP_RM: case RP_RB:
 178                 {
 179                     aRetval.setX(1.0);
 180                     break;
 181                 }
 182
 183                 default :
 184                 {
 185                     break;
 186                 }
 187             }
 188
 189             // position changes Y
 190             switch(eRectPoint)
 191             {
 192                 case RP_LT: case RP_MT: case RP_RT:
 193                 {
 194                     aRetval.setY(-1.0);
 195                     break;
 196                 }
 197
 198                 case RP_LB: case RP_MB: case RP_RB:
 199                 {
 200                     aRetval.setY(1.0);
 201                     break;
 202                 }
 203
 204                 default :
 205                 {
 206                     break;
 207                 }
 208             }
 209
 210             return aRetval;
 211         }
 212     } // end of anonymous namespace
 213 } // end of namespace drawinglayer
 214
 215 //////////////////////////////////////////////////////////////////////////////
 216
 217 namespace drawinglayer
 218 {
 219     namespace primitive2d
 220     {
 221         attribute::SdrLineAttribute* createNewSdrLineAttribute(const SfxItemSet& rSet)
 222         {
 223             attribute::SdrLineAttribute* pRetval(0L);
 224             const XLineStyle eStyle(((XLineStyleItem&)(rSet.Get(XATTR_LINESTYLE))).GetValue());
 225
 226             if(XLINE_NONE != eStyle)
 227             {
 228                 sal_uInt16 nTransparence(((const XLineTransparenceItem&)(rSet.Get(XATTR_LINETRANSPARENCE))).GetValue());
 229
 230                 if(nTransparence > 100)
 231                 {
 232                     nTransparence = 100;
 233                 }
 234
 235                 if(100 != nTransparence)
 236                 {
 237                     const sal_uInt32 nWidth(((const XLineWidthItem&)(rSet.Get(XATTR_LINEWIDTH))).GetValue());
 238                     const Color aColor(((const XLineColorItem&)(rSet.Get(XATTR_LINECOLOR))).GetColorValue());
 239                     const XLineJoint eJoint(((const XLineJointItem&)(rSet.Get(XATTR_LINEJOINT))).GetValue());
 240                     ::std::vector< double > aDotDashArray;
 241                     double fFullDotDashLen(0.0);
 242
 243                     if(XLINE_DASH == eStyle)
 244                     {
 245                         const XDash& rDash = ((const XLineDashItem&)(rSet.Get(XATTR_LINEDASH))).GetDashValue();
 246
 247                         if(rDash.GetDots() || rDash.GetDashes())
 248                         {
 249                             fFullDotDashLen = rDash.CreateDotDashArray(aDotDashArray, (double)nWidth);
 250                         }
 251                     }
 252
 253                     pRetval = new attribute::SdrLineAttribute(
 254                         XLineJointtoB2DLineJoin(eJoint),
 255                         (double)nWidth,
 256                         (double)nTransparence * 0.01,
 257                         aColor.getBColor(),
 258                         aDotDashArray,
 259                         fFullDotDashLen);
 260                 }
 261             }
 262
 263             return pRetval;
 264         }
 265
 266         attribute::SdrLineStartEndAttribute* createNewSdrLineStartEndAttribute(const SfxItemSet& rSet, double fWidth)
 267         {
 268             attribute::SdrLineStartEndAttribute* pRetval(0L);
 269             const sal_Int32 nTempStartWidth(((const XLineStartWidthItem&)(rSet.Get(XATTR_LINESTARTWIDTH))).GetValue());
 270             const sal_Int32 nTempEndWidth(((const XLineEndWidthItem&)(rSet.Get(XATTR_LINEENDWIDTH))).GetValue());
 271             basegfx::B2DPolyPolygon aStartPolyPolygon;
 272             basegfx::B2DPolyPolygon aEndPolyPolygon;
 273             double fStartWidth(0.0);
 274             double fEndWidth(0.0);
 275             bool bStartActive(false);
 276             bool bEndActive(false);
 277             bool bStartCentered(true);
 278             bool bEndCentered(true);
 279
 280             if(nTempStartWidth)
 281             {
 282                 if(nTempStartWidth < 0L)
 283                 {
 284                     fStartWidth = ((double)(-nTempStartWidth) * fWidth) * 0.01;
 285                 }
 286                 else
 287                 {
 288                     fStartWidth = (double)nTempStartWidth;
 289                 }
 290
 291                 if(0.0 != fStartWidth)
 292                 {
 293                     aStartPolyPolygon = basegfx::B2DPolyPolygon(((const XLineStartItem&)(rSet.Get(XATTR_LINESTART))).GetLineStartValue());
 294
 295                     if(aStartPolyPolygon.count() && aStartPolyPolygon.getB2DPolygon(0L).count())
 296                     {
 297                         bStartActive = true;
 298                         bStartCentered = ((const XLineStartCenterItem&)(rSet.Get(XATTR_LINESTARTCENTER))).GetValue();
 299                     }
 300                 }
 301             }
 302
 303             if(nTempEndWidth)
 304             {
 305                 if(nTempEndWidth < 0L)
 306                 {
 307                     fEndWidth = ((double)(-nTempEndWidth) * fWidth) * 0.01;
 308                 }
 309                 else
 310                 {
 311                     fEndWidth = (double)nTempEndWidth;
 312                 }
 313
 314                 if(0.0 != fEndWidth)
 315                 {
 316                     aEndPolyPolygon = basegfx::B2DPolyPolygon(((const XLineEndItem&)(rSet.Get(XATTR_LINEEND))).GetLineEndValue());
 317
 318                     if(aEndPolyPolygon.count() && aEndPolyPolygon.getB2DPolygon(0L).count())
 319                     {
 320                         bEndActive = true;
 321                         bEndCentered = ((const XLineEndCenterItem&)(rSet.Get(XATTR_LINEENDCENTER))).GetValue();
 322                     }
 323                 }
 324             }
 325
 326             if(bStartActive || bEndActive)
 327             {
 328                 pRetval = new attribute::SdrLineStartEndAttribute(aStartPolyPolygon, aEndPolyPolygon, fStartWidth, fEndWidth, bStartActive, bEndActive, bStartCentered, bEndCentered);
 329             }
 330
 331             return pRetval;
 332         }
 333
 334         attribute::SdrShadowAttribute* createNewSdrShadowAttribute(const SfxItemSet& rSet)
 335         {
 336             attribute::SdrShadowAttribute* pRetval(0L);
 337             const bool bShadow(((SdrShadowItem&)rSet.Get(SDRATTR_SHADOW)).GetValue());
 338
 339             if(bShadow)
 340             {
 341                 sal_uInt16 nTransparence(((SdrShadowTransparenceItem&)(rSet.Get(SDRATTR_SHADOWTRANSPARENCE))).GetValue());
 342
 343                 if(nTransparence > 100)
 344                 {
 345                     nTransparence = 100;
 346                 }
 347
 348                 if(nTransparence)
 349                 {
 350                     sal_uInt16 nFillTransparence(((const XFillTransparenceItem&)(rSet.Get(XATTR_FILLTRANSPARENCE))).GetValue());
 351
 352                     if(nFillTransparence > 100)
 353                     {
 354                         nFillTransparence = 100;
 355                     }
 356
 357                     if(nTransparence == nFillTransparence)
 358                     {
 359                         // shadow does not really have an own transparence, but the application
 360                         // sets the shadow transparence equal to the object transparence for
 361                         // convenience. This is not useful for primitive creation, so take
 362                         // this as no shadow transparence
 363                         nTransparence = 0;
 364                     }
 365                 }
 366
 367                 if(100 != nTransparence)
 368                 {
 369                     const basegfx::B2DVector aOffset(
 370                         (double)((SdrShadowXDistItem&)(rSet.Get(SDRATTR_SHADOWXDIST))).GetValue(),
 371                         (double)((SdrShadowYDistItem&)(rSet.Get(SDRATTR_SHADOWYDIST))).GetValue());
 372                     const Color aColor(((SdrShadowColorItem&)(rSet.Get(SDRATTR_SHADOWCOLOR))).GetColorValue());
 373
 374                     pRetval = new attribute::SdrShadowAttribute(aOffset, (double)nTransparence * 0.01, aColor.getBColor());
 375                 }
 376             }
 377
 378             return pRetval;
 379         }
 380
 381         attribute::SdrFillAttribute* createNewSdrFillAttribute(const SfxItemSet& rSet)
 382         {
 383             attribute::SdrFillAttribute* pRetval(0L);
 384             const XFillStyle eStyle(((XFillStyleItem&)(rSet.Get(XATTR_FILLSTYLE))).GetValue());
 385
 386             if(XFILL_NONE != eStyle)
 387             {
 388                 sal_uInt16 nTransparence(((const XFillTransparenceItem&)(rSet.Get(XATTR_FILLTRANSPARENCE))).GetValue());
 389
 390                 if(nTransparence > 100)
 391                 {
 392                     nTransparence = 100;
 393                 }
 394
 395                 if(100 != nTransparence)
 396                 {
 397                     const Color aColor(((const XFillColorItem&)(rSet.Get(XATTR_FILLCOLOR))).GetColorValue());
 398                     attribute::FillGradientAttribute* pGradient(0L);
 399                     attribute::FillHatchAttribute* pHatch(0L);
 400                     attribute::SdrFillBitmapAttribute* pBitmap(0L);
 401
 402                     switch(eStyle)
 403                     {
 404                         case XFILL_NONE : // for warnings
 405                         case XFILL_SOLID :
 406                         {
 407                             // nothing to do, color is defined
 408                             break;
 409                         }
 410                         case XFILL_GRADIENT :
 411                         {
 412                             XGradient aGradient(((XFillGradientItem&)(rSet.Get(XATTR_FILLGRADIENT))).GetGradientValue());
 413
 414                             const Color aStartColor(aGradient.GetStartColor());
 415                             const sal_uInt16 nStartIntens(aGradient.GetStartIntens());
 416                             basegfx::BColor aStart(aStartColor.getBColor());
 417
 418                             if(nStartIntens != 100)
 419                             {
 420                                 const basegfx::BColor aBlack;
 421                                 aStart = interpolate(aBlack, aStart, (double)nStartIntens * 0.01);
 422                             }
 423
 424                             const Color aEndColor(aGradient.GetEndColor());
 425                             const sal_uInt16 nEndIntens(aGradient.GetEndIntens());
 426                             basegfx::BColor aEnd(aEndColor.getBColor());
 427
 428                             if(nEndIntens != 100)
 429                             {
 430                                 const basegfx::BColor aBlack;
 431                                 aEnd = interpolate(aBlack, aEnd, (double)nEndIntens * 0.01);
 432                             }
 433
 434                             pGradient = new attribute::FillGradientAttribute(
 435                                 XGradientStyleToGradientStyle(aGradient.GetGradientStyle()),
 436                                 (double)aGradient.GetBorder() * 0.01,
 437                                 (double)aGradient.GetXOffset() * 0.01,
 438                                 (double)aGradient.GetYOffset() * 0.01,
 439                                 (double)aGradient.GetAngle() * F_PI1800,
 440                                 aStart,
 441                                 aEnd,
 442                                 ((const XGradientStepCountItem&)rSet.Get(XATTR_GRADIENTSTEPCOUNT)).GetValue());
 443
 444                             break;
 445                         }
 446                         case XFILL_HATCH :
 447                         {
 448                             const XHatch& rHatch(((XFillHatchItem&)(rSet.Get(XATTR_FILLHATCH))).GetHatchValue());
 449                             const Color aColorB(rHatch.GetColor());
 450
 451                             pHatch = new attribute::FillHatchAttribute(
 452                                 XHatchStyleToHatchStyle(rHatch.GetHatchStyle()),
 453                                 (double)rHatch.GetDistance(),
 454                                 (double)rHatch.GetAngle() * F_PI1800,
 455                                 aColorB.getBColor(),
 456                                 ((const XFillBackgroundItem&)(rSet.Get(XATTR_FILLBACKGROUND))).GetValue());
 457
 458                             break;
 459                         }
 460                         case XFILL_BITMAP :
 461                         {
 462                             pBitmap = createNewSdrFillBitmapAttribute(rSet);
 463                             break;
 464                         }
 465                     }
 466
 467                     pRetval = new attribute::SdrFillAttribute(
 468                         (double)nTransparence * 0.01,
 469                         aColor.getBColor(),
 470                         pGradient, pHatch, pBitmap);
 471                 }
 472             }
 473
 474             return pRetval;
 475         }
 476
 477         // #i101508# Support handing over given text-to-border distances
 478         attribute::SdrTextAttribute* createNewSdrTextAttribute(
 479             const SfxItemSet& rSet,
 480             const SdrText& rText,
 481             const sal_Int32* pLeft,
 482             const sal_Int32* pUpper,
 483             const sal_Int32* pRight,
 484             const sal_Int32* pLower)
 485         {
 486             attribute::SdrTextAttribute* pRetval(0);
 487             const SdrTextObj& rTextObj = rText.GetObject();
 488
 489             if(rText.GetOutlinerParaObject() && rText.GetModel())
 490             {
 491                 // added TextEdit text suppression
 492                 bool bInEditMode(false);
 493
 494                 if(rText.GetObject().getTextCount() > 1)
 495                 {
 496                     bInEditMode = rTextObj.IsInEditMode() && rText.GetObject().getActiveText() == &rText;
 497                 }
 498                 else
 499                 {
 500                     bInEditMode = rTextObj.IsInEditMode();
 501                 }
 502
 503                 OutlinerParaObject aOutlinerParaObject(*rText.GetOutlinerParaObject());
 504
 505                 if(bInEditMode)
 506                 {
 507                     OutlinerParaObject* pTempObj = rTextObj.GetEditOutlinerParaObject();
 508
 509                     if(pTempObj)
 510                     {
 511                         aOutlinerParaObject = *pTempObj;
 512                         delete pTempObj;
 513                     }
 514                     else
 515                     {
 516                         // #i100537#
 517                         // GetEditOutlinerParaObject() returning no object does not mean that
 518                         // text edit mode is not active. Do not reset the flag here
 519                         // bInEditMode = false;
 520                     }
 521                 }
 522
 523                 const SdrFitToSizeType eFit(rTextObj.GetFitToSize());
 524                 const SdrTextAniKind eAniKind(rTextObj.GetTextAniKind());
 525
 526                 pRetval = new attribute::SdrTextAttribute(
 527                     rText,
 528                     aOutlinerParaObject,
 529                     ((const XFormTextStyleItem&)rSet.Get(XATTR_FORMTXTSTYLE)).GetValue(),
 530                     pLeft ? *pLeft : rTextObj.GetTextLeftDistance(),
 531                     pUpper ? *pUpper : rTextObj.GetTextUpperDistance(),
 532                     pRight ? *pRight : rTextObj.GetTextRightDistance(),
 533                     pLower ? *pLower : rTextObj.GetTextLowerDistance(),
 534                     rTextObj.GetTextHorizontalAdjust(rSet),
 535                     rTextObj.GetTextVerticalAdjust(rSet),
 536                     ((const SdrTextContourFrameItem&)rSet.Get(SDRATTR_TEXT_CONTOURFRAME)).GetValue(),
 537                     rTextObj.IsFitToSize(),
 538                     rTextObj.IsAutoFit(),
 539                     ((const XFormTextHideFormItem&)rSet.Get(XATTR_FORMTXTHIDEFORM)).GetValue(),
 540                     SDRTEXTANI_BLINK == eAniKind,
 541                     SDRTEXTANI_SCROLL == eAniKind || SDRTEXTANI_ALTERNATE == eAniKind || SDRTEXTANI_SLIDE == eAniKind,
 542                     bInEditMode,
 543                     ((const SdrTextFixedCellHeightItem&)rSet.Get(SDRATTR_TEXT_USEFIXEDCELLHEIGHT)).GetValue());
 544             }
 545
 546             return pRetval;
 547         }
 548
 549         attribute::FillGradientAttribute* createNewTransparenceGradientAttribute(const SfxItemSet& rSet)
 550         {
 551             attribute::FillGradientAttribute* pRetval = 0L;
 552             const SfxPoolItem* pGradientItem;
 553
 554             if(SFX_ITEM_SET == rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, TRUE, &pGradientItem) && ((XFillFloatTransparenceItem*)pGradientItem)->IsEnabled())
 555             {
 556                 // test if float transparence is completely transparent
 557                 const XGradient& rGradient = ((XFillFloatTransparenceItem*)pGradientItem)->GetGradientValue();
 558                 const sal_uInt8 nStartLuminance(rGradient.GetStartColor().GetLuminance());
 559                 const sal_uInt8 nEndLuminance(rGradient.GetEndColor().GetLuminance());
 560                                 const bool bCompletelyTransparent(0xff == nStartLuminance && 0xff == nEndLuminance);
 561
 562                 if(!bCompletelyTransparent)
 563                 {
 564                     const double fStartLum(nStartLuminance / 255.0);
 565                     const double fEndLum(nEndLuminance / 255.0);
 566
 567                     pRetval = new attribute::FillGradientAttribute(
 568                         XGradientStyleToGradientStyle(rGradient.GetGradientStyle()),
 569                         (double)rGradient.GetBorder() * 0.01,
 570                         (double)rGradient.GetXOffset() * 0.01,
 571                         (double)rGradient.GetYOffset() * 0.01,
 572                         (double)rGradient.GetAngle() * F_PI1800,
 573                         basegfx::BColor(fStartLum, fStartLum, fStartLum),
 574                         basegfx::BColor(fEndLum, fEndLum, fEndLum),
 575                         0);
 576                 }
 577             }
 578
 579             return pRetval;
 580         }
 581
 582         attribute::SdrFillBitmapAttribute* createNewSdrFillBitmapAttribute(const SfxItemSet& rSet)
 583         {
 584             attribute::SdrFillBitmapAttribute* pRetval(0L);
 585             Bitmap aBitmap((((const XFillBitmapItem&)(rSet.Get(XATTR_FILLBITMAP))).GetBitmapValue()).GetBitmap());
 586
 587             // make sure it's not empty, use default instead
 588             if(aBitmap.IsEmpty())
 589             {
 590                 aBitmap = Bitmap(Size(4,4), 8);
 591             }
 592
 593             // if there is no logical size, create a size from pixel size and set MapMode accordingly
 594             if(0L == aBitmap.GetPrefSize().Width() || 0L == aBitmap.GetPrefSize().Height())
 595             {
 596                 aBitmap.SetPrefSize(aBitmap.GetSizePixel());
 597                 aBitmap.SetPrefMapMode(MAP_PIXEL);
 598             }
 599
 600             // convert size and MapMode to destination logical size and MapMode. The created
 601             // bitmap must have a valid logical size (PrefSize)
 602             const MapUnit aDestinationMapUnit((MapUnit)rSet.GetPool()->GetMetric(0));
 603
 604             if(aBitmap.GetPrefMapMode() != aDestinationMapUnit)
 605             {
 606                 // #i100360# for MAP_PIXEL, LogicToLogic will not work properly,
 607                 // so fallback to Application::GetDefaultDevice()
 608                 if(MAP_PIXEL == aBitmap.GetPrefMapMode().GetMapUnit())
 609                 {
 610                     aBitmap.SetPrefSize(Application::GetDefaultDevice()->PixelToLogic(
 611                         aBitmap.GetPrefSize(), aDestinationMapUnit));
 612                 }
 613                 else
 614                 {
 615                     aBitmap.SetPrefSize(OutputDevice::LogicToLogic(
 616                         aBitmap.GetPrefSize(), aBitmap.GetPrefMapMode(), aDestinationMapUnit));
 617                 }
 618             }
 619
 620             // get size
 621             const basegfx::B2DVector aSize(
 622                 (double)((const SfxMetricItem&)(rSet.Get(XATTR_FILLBMP_SIZEX))).GetValue(),
 623                 (double)((const SfxMetricItem&)(rSet.Get(XATTR_FILLBMP_SIZEY))).GetValue());
 624             const basegfx::B2DVector aOffset(
 625                 (double)((const SfxUInt16Item&) (rSet.Get(XATTR_FILLBMP_TILEOFFSETX))).GetValue(),
 626                 (double)((const SfxUInt16Item&) (rSet.Get(XATTR_FILLBMP_TILEOFFSETY))).GetValue());
 627             const basegfx::B2DVector aOffsetPosition(
 628                 (double)((const SfxUInt16Item&) (rSet.Get(XATTR_FILLBMP_POSOFFSETX))).GetValue(),
 629                 (double)((const SfxUInt16Item&) (rSet.Get(XATTR_FILLBMP_POSOFFSETY))).GetValue());
 630
 631             pRetval = new attribute::SdrFillBitmapAttribute(
 632                 aBitmap,
 633                 aSize,
 634                 aOffset,
 635                 aOffsetPosition,
 636                 RectPointToB2DVector((RECT_POINT)((const SfxEnumItem&)(rSet.Get(XATTR_FILLBMP_POS))).GetValue()),
 637                 ((const SfxBoolItem&) (rSet.Get(XATTR_FILLBMP_TILE))).GetValue(),
 638                 ((const SfxBoolItem&) (rSet.Get(XATTR_FILLBMP_STRETCH))).GetValue(),
 639                 ((const SfxBoolItem&) (rSet.Get(XATTR_FILLBMP_SIZELOG))).GetValue());
 640
 641             return pRetval;
 642         }
 643
 644         attribute::SdrShadowTextAttribute* createNewSdrShadowTextAttribute(const SfxItemSet& rSet, const SdrText& rText, bool bSuppressText)
 645         {
 646             attribute::SdrShadowTextAttribute* pRetval(0L);
 647             attribute::SdrShadowAttribute* pShadow(0L);
 648             attribute::SdrTextAttribute* pText(0L);
 649
 650             // #i98072# added option to suppress text
 651             // look for text first
 652             if(!bSuppressText)
 653             {
 654                 pText = createNewSdrTextAttribute(rSet, rText);
 655             }
 656
 657             // try shadow
 658             pShadow = createNewSdrShadowAttribute(rSet);
 659
 660             if(pShadow && !pShadow->isVisible())
 661             {
 662                 delete pShadow;
 663                 pShadow = 0L;
 664             }
 665
 666             if(pText || pShadow)
 667             {
 668                 pRetval = new attribute::SdrShadowTextAttribute(pShadow, pText);
 669             }
 670
 671             return pRetval;
 672         }
 673
 674         attribute::SdrLineShadowTextAttribute* createNewSdrLineShadowTextAttribute(const SfxItemSet& rSet, const SdrText& rText)
 675         {
 676             attribute::SdrLineShadowTextAttribute* pRetval(0L);
 677             attribute::SdrLineAttribute* pLine(0L);
 678             attribute::SdrLineStartEndAttribute* pLineStartEnd(0L);
 679             attribute::SdrShadowAttribute* pShadow(0L);
 680             attribute::SdrTextAttribute* pText(0L);
 681             bool bFontworkHideContour(false);
 682
 683             // look for text first
 684             pText = createNewSdrTextAttribute(rSet, rText);
 685
 686             // when object has text and text is fontwork and hide contour is set for fontwork, force
 687             // line and fill style to empty
 688             if(pText && pText->getSdrFormTextAttribute() && pText->isHideContour())
 689             {
 690                 bFontworkHideContour = true;
 691             }
 692
 693             // try line style
 694             if(!bFontworkHideContour)
 695             {
 696                 pLine = createNewSdrLineAttribute(rSet);
 697
 698                 if(pLine && !pLine->isVisible())
 699                 {
 700                     delete pLine;
 701                     pLine = 0L;
 702                 }
 703
 704                 if(pLine)
 705                 {
 706                     // try LineStartEnd
 707                     pLineStartEnd = createNewSdrLineStartEndAttribute(rSet, pLine->getWidth());
 708
 709                     if(pLineStartEnd && !pLineStartEnd->isVisible())
 710                     {
 711                         delete pLineStartEnd;
 712                         pLineStartEnd = 0L;
 713                     }
 714                 }
 715             }
 716
 717             // try shadow
 718             if(pLine || pText)
 719             {
 720                 pShadow = createNewSdrShadowAttribute(rSet);
 721
 722                 if(pShadow && !pShadow->isVisible())
 723                 {
 724                     delete pShadow;
 725                     pShadow = 0L;
 726                 }
 727             }
 728
 729             if(pLine || pText)
 730             {
 731                 pRetval = new attribute::SdrLineShadowTextAttribute(pLine, pLineStartEnd, pShadow, pText);
 732             }
 733
 734             return pRetval;
 735         }
 736
 737         attribute::SdrLineFillShadowTextAttribute* createNewSdrLineFillShadowTextAttribute(const SfxItemSet& rSet, const SdrText& rText)
 738         {
 739             attribute::SdrLineFillShadowTextAttribute* pRetval(0L);
 740             attribute::SdrLineAttribute* pLine(0L);
 741             attribute::SdrFillAttribute* pFill(0L);
 742             attribute::SdrLineStartEndAttribute* pLineStartEnd(0L);
 743             attribute::SdrShadowAttribute* pShadow(0L);
 744             attribute::FillGradientAttribute* pFillFloatTransGradient(0L);
 745             attribute::SdrTextAttribute* pText(0L);
 746             bool bFontworkHideContour(false);
 747
 748             // look for text first
 749             pText = createNewSdrTextAttribute(rSet, rText);
 750
 751             // when object has text and text is fontwork and hide contour is set for fontwork, force
 752             // line and fill style to empty
 753             if(pText && pText->getSdrFormTextAttribute() && pText->isHideContour())
 754             {
 755                 bFontworkHideContour = true;
 756             }
 757
 758             // try line style
 759             if(!bFontworkHideContour)
 760             {
 761                 pLine = createNewSdrLineAttribute(rSet);
 762
 763                 if(pLine && !pLine->isVisible())
 764                 {
 765                     delete pLine;
 766                     pLine = 0L;
 767                 }
 768
 769                 if(pLine)
 770                 {
 771                     // try LineStartEnd
 772                     pLineStartEnd = createNewSdrLineStartEndAttribute(rSet, pLine->getWidth());
 773
 774                     if(pLineStartEnd && !pLineStartEnd->isVisible())
 775                     {
 776                         delete pLineStartEnd;
 777                         pLineStartEnd = 0L;
 778                     }
 779                 }
 780             }
 781
 782             // try fill style
 783             if(!bFontworkHideContour)
 784             {
 785                 pFill = createNewSdrFillAttribute(rSet);
 786
 787                 if(pFill && !pFill->isVisible())
 788                 {
 789                     delete pFill;
 790                     pFill = 0L;
 791                 }
 792
 793                 if(pFill)
 794                 {
 795                     // try fillfloattransparence
 796                     pFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
 797                 }
 798             }
 799
 800             // try shadow
 801             if(pLine || pFill || pText)
 802             {
 803                 pShadow = createNewSdrShadowAttribute(rSet);
 804
 805                 if(pShadow && !pShadow->isVisible())
 806                 {
 807                     delete pShadow;
 808                     pShadow = 0L;
 809                 }
 810             }
 811
 812             if(pLine || pFill || pText)
 813             {
 814                 pRetval = new attribute::SdrLineFillShadowTextAttribute(pLine, pFill, pLineStartEnd, pShadow, pFillFloatTransGradient, pText);
 815             }
 816
 817             return pRetval;
 818         }
 819
 820         attribute::SdrLineFillShadowAttribute* createNewSdrLineFillShadowAttribute(const SfxItemSet& rSet, bool bSuppressFill)
 821         {
 822             attribute::SdrLineFillShadowAttribute* pRetval(0L);
 823             attribute::SdrLineAttribute* pLine(0L);
 824             attribute::SdrFillAttribute* pFill(0L);
 825             attribute::SdrLineStartEndAttribute* pLineStartEnd(0L);
 826             attribute::SdrShadowAttribute* pShadow(0L);
 827             attribute::FillGradientAttribute* pFillFloatTransGradient(0L);
 828
 829             // try line style
 830             pLine = createNewSdrLineAttribute(rSet);
 831
 832             if(pLine && !pLine->isVisible())
 833             {
 834                 delete pLine;
 835                 pLine = 0L;
 836             }
 837
 838             if(pLine)
 839             {
 840                 // try LineStartEnd
 841                 pLineStartEnd = createNewSdrLineStartEndAttribute(rSet, pLine->getWidth());
 842
 843                 if(pLineStartEnd && !pLineStartEnd->isVisible())
 844                 {
 845                     delete pLineStartEnd;
 846                     pLineStartEnd = 0L;
 847                 }
 848             }
 849
 850             // try fill style
 851             pFill = bSuppressFill ? 0 : createNewSdrFillAttribute(rSet);
 852
 853             if(pFill && !pFill->isVisible())
 854             {
 855                 delete pFill;
 856                 pFill = 0L;
 857             }
 858
 859             if(pFill)
 860             {
 861                 // try fillfloattransparence
 862                 pFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
 863             }
 864
 865             // try shadow
 866             if(pLine || pFill)
 867             {
 868                 pShadow = createNewSdrShadowAttribute(rSet);
 869
 870                 if(pShadow && !pShadow->isVisible())
 871                 {
 872                     delete pShadow;
 873                     pShadow = 0L;
 874                 }
 875             }
 876
 877             if(pLine || pFill)
 878             {
 879                 pRetval = new attribute::SdrLineFillShadowAttribute(pLine, pFill, pLineStartEnd, pShadow, pFillFloatTransGradient);
 880             }
 881
 882             return pRetval;
 883         }
 884
 885         attribute::SdrSceneAttribute* createNewSdrSceneAttribute(const SfxItemSet& rSet)
 886         {
 887             // get perspective
 888             ::com::sun::star::drawing::ProjectionMode aProjectionMode(::com::sun::star::drawing::ProjectionMode_PARALLEL);
 889             const sal_uInt16 nProjectionValue(((const Svx3DPerspectiveItem&)rSet.Get(SDRATTR_3DSCENE_PERSPECTIVE)).GetValue());
 890
 891             if(1L == nProjectionValue)
 892             {
 893                 aProjectionMode = ::com::sun::star::drawing::ProjectionMode_PERSPECTIVE;
 894             }
 895
 896             // get distance
 897             const double fDistance(((const Svx3DDistanceItem&)rSet.Get(SDRATTR_3DSCENE_DISTANCE)).GetValue());
 898
 899             // get shadow slant
 900             const double fShadowSlant(F_PI180 * ((const Svx3DShadowSlantItem&)rSet.Get(SDRATTR_3DSCENE_SHADOW_SLANT)).GetValue());
 901
 902             // get shade mode
 903             ::com::sun::star::drawing::ShadeMode aShadeMode(::com::sun::star::drawing::ShadeMode_FLAT);
 904             const sal_uInt16 nShadeValue(((const Svx3DShadeModeItem&)rSet.Get(SDRATTR_3DSCENE_SHADE_MODE)).GetValue());
 905
 906             if(1L == nShadeValue)
 907             {
 908                 aShadeMode = ::com::sun::star::drawing::ShadeMode_PHONG;
 909             }
 910             else if(2L == nShadeValue)
 911             {
 912                 aShadeMode = ::com::sun::star::drawing::ShadeMode_SMOOTH;
 913             }
 914             else if(3L == nShadeValue)
 915             {
 916                 aShadeMode = ::com::sun::star::drawing::ShadeMode_DRAFT;
 917             }
 918
 919             // get two sided lighting
 920             const bool bTwoSidedLighting(((const Svx3DTwoSidedLightingItem&)rSet.Get(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING)).GetValue());
 921
 922             return new attribute::SdrSceneAttribute(fDistance, fShadowSlant, aProjectionMode, aShadeMode, bTwoSidedLighting);
 923         }
 924
 925         attribute::SdrLightingAttribute* createNewSdrLightingAttribute(const SfxItemSet& rSet)
 926         {
 927             // extract lights from given SfxItemSet (from scene)
 928             ::std::vector< attribute::Sdr3DLightAttribute > aLightVector;
 929
 930             if(((const Svx3DLightOnOff1Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_1)).GetValue())
 931             {
 932                 const basegfx::BColor aColor(((const Svx3DLightcolor1Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_1)).GetValue().getBColor());
 933                 const basegfx::B3DVector aDirection(((const Svx3DLightDirection1Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_1)).GetValue());
 934                 aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, true));
 935             }
 936
 937             if(((const Svx3DLightOnOff2Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_2)).GetValue())
 938             {
 939                 const basegfx::BColor aColor(((const Svx3DLightcolor2Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_2)).GetValue().getBColor());
 940                 const basegfx::B3DVector aDirection(((const Svx3DLightDirection2Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_2)).GetValue());
 941                 aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
 942             }
 943
 944             if(((const Svx3DLightOnOff3Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_3)).GetValue())
 945             {
 946                 const basegfx::BColor aColor(((const Svx3DLightcolor3Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_3)).GetValue().getBColor());
 947                 const basegfx::B3DVector aDirection(((const Svx3DLightDirection3Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_3)).GetValue());
 948                 aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
 949             }
 950
 951             if(((const Svx3DLightOnOff4Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_4)).GetValue())
 952             {
 953                 const basegfx::BColor aColor(((const Svx3DLightcolor4Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_4)).GetValue().getBColor());
 954                 const basegfx::B3DVector aDirection(((const Svx3DLightDirection4Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_4)).GetValue());
 955                 aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
 956             }
 957
 958             if(((const Svx3DLightOnOff5Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_5)).GetValue())
 959             {
 960                 const basegfx::BColor aColor(((const Svx3DLightcolor5Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_5)).GetValue().getBColor());
 961                 const basegfx::B3DVector aDirection(((const Svx3DLightDirection5Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_5)).GetValue());
 962                 aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
 963             }
 964
 965             if(((const Svx3DLightOnOff6Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_6)).GetValue())
 966             {
 967                 const basegfx::BColor aColor(((const Svx3DLightcolor6Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_6)).GetValue().getBColor());
 968                 const basegfx::B3DVector aDirection(((const Svx3DLightDirection6Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_6)).GetValue());
 969                 aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
 970             }
 971
 972             if(((const Svx3DLightOnOff7Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_7)).GetValue())
 973             {
 974                 const basegfx::BColor aColor(((const Svx3DLightcolor7Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_7)).GetValue().getBColor());
 975                 const basegfx::B3DVector aDirection(((const Svx3DLightDirection7Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_7)).GetValue());
 976                 aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
 977             }
 978
 979             if(((const Svx3DLightOnOff8Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTON_8)).GetValue())
 980             {
 981                 const basegfx::BColor aColor(((const Svx3DLightcolor8Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_8)).GetValue().getBColor());
 982                 const basegfx::B3DVector aDirection(((const Svx3DLightDirection8Item&)rSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_8)).GetValue());
 983                 aLightVector.push_back(attribute::Sdr3DLightAttribute(aColor, aDirection, false));
 984             }
 985
 986             // get ambient color
 987             const Color aAmbientValue(((const Svx3DAmbientcolorItem&)rSet.Get(SDRATTR_3DSCENE_AMBIENTCOLOR)).GetValue());
 988             const basegfx::BColor aAmbientLight(aAmbientValue.getBColor());
 989
 990             return new attribute::SdrLightingAttribute(aAmbientLight, aLightVector);
 991         }
 992
 993         void calculateRelativeCornerRadius(sal_Int32 nRadius, const basegfx::B2DRange& rObjectRange, double& rfCornerRadiusX, double& rfCornerRadiusY)
 994         {
 995             rfCornerRadiusX = rfCornerRadiusY = (double)nRadius;
 996
 997             if(0.0 != rfCornerRadiusX)
 998             {
 999                 const double fHalfObjectWidth(rObjectRange.getWidth() * 0.5);
1000
1001                 if(0.0 != fHalfObjectWidth)
1002                 {
1003                     if(rfCornerRadiusX < 0.0)
1004                     {
1005                         rfCornerRadiusX = 0.0;
1006                     }
1007
1008                     if(rfCornerRadiusX > fHalfObjectWidth)
1009                     {
1010                         rfCornerRadiusX = fHalfObjectWidth;
1011                     }
1012
1013                     rfCornerRadiusX /= fHalfObjectWidth;
1014                 }
1015                 else
1016                 {
1017                     rfCornerRadiusX = 0.0;
1018                 }
1019             }
1020
1021             if(0.0 != rfCornerRadiusY)
1022             {
1023                 const double fHalfObjectHeight(rObjectRange.getHeight() * 0.5);
1024
1025                 if(0.0 != fHalfObjectHeight)
1026                 {
1027                     if(rfCornerRadiusY < 0.0)
1028                     {
1029                         rfCornerRadiusY = 0.0;
1030                     }
1031
1032                     if(rfCornerRadiusY > fHalfObjectHeight)
1033                     {
1034                         rfCornerRadiusY = fHalfObjectHeight;
1035                     }
1036
1037                     rfCornerRadiusY /= fHalfObjectHeight;
1038                 }
1039                 else
1040                 {
1041                     rfCornerRadiusY = 0.0;
1042                 }
1043             }
1044         }
1045
1046         // #i101508# Support handing over given text-to-border distances
1047         attribute::SdrFillTextAttribute* createNewSdrFillTextAttribute(
1048             const SfxItemSet& rSet,
1049             const SdrText* pSdrText,
1050             const sal_Int32* pLeft,
1051             const sal_Int32* pUpper,
1052             const sal_Int32* pRight,
1053             const sal_Int32* pLower)
1054         {
1055             attribute::SdrFillTextAttribute* pRetval(0L);
1056             attribute::SdrFillAttribute* pFill(0L);
1057             attribute::FillGradientAttribute* pFillFloatTransGradient(0L);
1058             attribute::SdrTextAttribute* pText(0L);
1059             bool bFontworkHideContour(false);
1060
1061             // look for text first
1062             if(pSdrText)
1063             {
1064                 pText = createNewSdrTextAttribute(rSet, *pSdrText, pLeft, pUpper, pRight, pLower);
1065             }
1066
1067             // when object has text and text is fontwork and hide contour is set for fontwork, force
1068             // fill style to empty
1069             if(pText && pText->getSdrFormTextAttribute() && pText->isHideContour())
1070             {
1071                 bFontworkHideContour = true;
1072             }
1073
1074             // try fill style
1075             if(!bFontworkHideContour)
1076             {
1077                 pFill = createNewSdrFillAttribute(rSet);
1078
1079                 if(pFill && !pFill->isVisible())
1080                 {
1081                     delete pFill;
1082                     pFill = 0L;
1083                 }
1084
1085                 if(pFill)
1086                 {
1087                     // try fillfloattransparence
1088                     pFillFloatTransGradient = createNewTransparenceGradientAttribute(rSet);
1089                 }
1090             }
1091
1092             if(pFill || pText)
1093             {
1094                 pRetval = new attribute::SdrFillTextAttribute(pFill, pFillFloatTransGradient, pText);
1095             }
1096
1097             return pRetval;
1098         }
1099
1100     } // end of namespace primitive2d
1101 } // end of namespace drawinglayer
1102
1103 //////////////////////////////////////////////////////////////////////////////
1104 // eof