svx/source/xoutdev/xtabgrdt.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 <XPropertyTable.hxx>
  21
  22 #include <vcl/virdev.hxx>
  23 #include <svx/strings.hrc>
  24 #include <svx/dialmgr.hxx>
  25 #include <svx/xtable.hxx>
  26
  27 #include <rtl/ustrbuf.hxx>
  28 #include <vcl/svapp.hxx>
  29 #include <vcl/settings.hxx>
  30
  31 #include <drawinglayer/attribute/fillgradientattribute.hxx>
  32 #include <drawinglayer/primitive2d/PolyPolygonGradientPrimitive2D.hxx>
  33 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  34 #include <drawinglayer/processor2d/baseprocessor2d.hxx>
  35 #include <drawinglayer/processor2d/processor2dtools.hxx>
  36 #include <basegfx/polygon/b2dpolygontools.hxx>
  37 #include <memory>
  38
  39 using namespace com::sun::star;
  40
  41 XGradientList::XGradientList( const OUString& rPath, const OUString& rReferer )
  42 :   XPropertyList( XPropertyListType::Gradient, rPath, rReferer )
  43 {
  44 }
  45
  46 XGradientList::~XGradientList()
  47 {
  48 }
  49
  50 void XGradientList::Replace(std::unique_ptr<XGradientEntry> pEntry, tools::Long nIndex)
  51 {
  52     XPropertyList::Replace(std::move(pEntry), nIndex);
  53 }
  54
  55 XGradientEntry* XGradientList::GetGradient(tools::Long nIndex) const
  56 {
  57     return static_cast<XGradientEntry*>( XPropertyList::Get( nIndex ) );
  58 }
  59
  60 uno::Reference< container::XNameContainer > XGradientList::createInstance()
  61 {
  62     return uno::Reference< container::XNameContainer >(
  63         SvxUnoXGradientTable_createInstance( this ),
  64         uno::UNO_QUERY );
  65 }
  66
  67 bool XGradientList::Create()
  68 {
  69     OUStringBuffer aStr(SvxResId(RID_SVXSTR_GRADIENT));
  70     aStr.append(" 1");
  71     sal_Int32 nLen = aStr.getLength() - 1;
  72     Insert(std::make_unique<XGradientEntry>(XGradient(COL_BLACK,   COL_WHITE, css::awt::GradientStyle_LINEAR    ,    0_deg10,10,10, 0,100,100),aStr.toString()));
  73     aStr[nLen] = '2';
  74     Insert(std::make_unique<XGradientEntry>(XGradient(COL_BLUE,    COL_RED,   css::awt::GradientStyle_AXIAL     ,  300_deg10,20,20,10,100,100),aStr.toString()));
  75     aStr[nLen] = '3';
  76     Insert(std::make_unique<XGradientEntry>(XGradient(COL_RED,     COL_YELLOW,css::awt::GradientStyle_RADIAL    ,  600_deg10,30,30,20,100,100),aStr.toString()));
  77     aStr[nLen] = '4';
  78     Insert(std::make_unique<XGradientEntry>(XGradient(COL_YELLOW , COL_GREEN, css::awt::GradientStyle_ELLIPTICAL,  900_deg10,40,40,30,100,100),aStr.toString()));
  79     aStr[nLen] = '5';
  80     Insert(std::make_unique<XGradientEntry>(XGradient(COL_GREEN  , COL_MAGENTA,css::awt::GradientStyle_SQUARE    , 1200_deg10,50,50,40,100,100),aStr.toString()));
  81     aStr[nLen] = '6';
  82     Insert(std::make_unique<XGradientEntry>(XGradient(COL_MAGENTA, COL_YELLOW ,css::awt::GradientStyle_RECT      , 1900_deg10,60,60,50,100,100),aStr.toString()));
  83
  84     return true;
  85 }
  86
  87 BitmapEx XGradientList::CreateBitmap( tools::Long nIndex, const Size& rSize ) const
  88 {
  89     BitmapEx aRetval;
  90
  91     OSL_ENSURE(nIndex < Count(), "OOps, access out of range (!)");
  92
  93     if(nIndex < Count())
  94     {
  95         const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
  96         // prepare polygon geometry for rectangle
  97         const basegfx::B2DPolygon aRectangle(
  98             basegfx::utils::createPolygonFromRect(
  99                 basegfx::B2DRange(0.0, 0.0, rSize.Width(), rSize.Height())));
 100
 101         const XGradient& rGradient = GetGradient(nIndex)->GetGradient();
 102         const sal_uInt16 nStartIntens(rGradient.GetStartIntens());
 103         basegfx::BColor aStart(rGradient.GetStartColor().getBColor());
 104
 105         if(nStartIntens != 100)
 106         {
 107             const basegfx::BColor aBlack;
 108             aStart = interpolate(aBlack, aStart, static_cast<double>(nStartIntens) * 0.01);
 109         }
 110
 111         const sal_uInt16 nEndIntens(rGradient.GetEndIntens());
 112         basegfx::BColor aEnd(rGradient.GetEndColor().getBColor());
 113
 114         if(nEndIntens != 100)
 115         {
 116             const basegfx::BColor aBlack;
 117             aEnd = interpolate(aBlack, aEnd, static_cast<double>(nEndIntens) * 0.01);
 118         }
 119
 120         drawinglayer::attribute::GradientStyle aGradientStyle(drawinglayer::attribute::GradientStyle::Rect);
 121
 122         switch(rGradient.GetGradientStyle())
 123         {
 124             case css::awt::GradientStyle_LINEAR :
 125             {
 126                 aGradientStyle = drawinglayer::attribute::GradientStyle::Linear;
 127                 break;
 128             }
 129             case css::awt::GradientStyle_AXIAL :
 130             {
 131                 aGradientStyle = drawinglayer::attribute::GradientStyle::Axial;
 132                 break;
 133             }
 134             case css::awt::GradientStyle_RADIAL :
 135             {
 136                 aGradientStyle = drawinglayer::attribute::GradientStyle::Radial;
 137                 break;
 138             }
 139             case css::awt::GradientStyle_ELLIPTICAL :
 140             {
 141                 aGradientStyle = drawinglayer::attribute::GradientStyle::Elliptical;
 142                 break;
 143             }
 144             case css::awt::GradientStyle_SQUARE :
 145             {
 146                 aGradientStyle = drawinglayer::attribute::GradientStyle::Square;
 147                 break;
 148             }
 149             default :
 150             {
 151                 aGradientStyle = drawinglayer::attribute::GradientStyle::Rect; // css::awt::GradientStyle_RECT
 152                 break;
 153             }
 154         }
 155
 156         const drawinglayer::attribute::FillGradientAttribute aFillGradient(
 157             aGradientStyle,
 158             static_cast<double>(rGradient.GetBorder()) * 0.01,
 159             static_cast<double>(rGradient.GetXOffset()) * 0.01,
 160             static_cast<double>(rGradient.GetYOffset()) * 0.01,
 161             static_cast<double>(rGradient.GetAngle().get()) * F_PI1800,
 162             aStart,
 163             aEnd);
 164
 165         const drawinglayer::primitive2d::Primitive2DReference aGradientPrimitive(
 166             new drawinglayer::primitive2d::PolyPolygonGradientPrimitive2D(
 167                 basegfx::B2DPolyPolygon(aRectangle),
 168                 aFillGradient));
 169
 170         const basegfx::BColor aBlack(0.0, 0.0, 0.0);
 171         const drawinglayer::primitive2d::Primitive2DReference aBlackRectanglePrimitive(
 172             new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(
 173                 aRectangle,
 174                 aBlack));
 175
 176         // prepare VirtualDevice
 177         ScopedVclPtrInstance< VirtualDevice > pVirtualDevice;
 178         const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D;
 179
 180         pVirtualDevice->SetOutputSizePixel(rSize);
 181         pVirtualDevice->SetDrawMode(rStyleSettings.GetHighContrastMode()
 182             ? DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient
 183             : DrawModeFlags::Default);
 184
 185         // create processor and draw primitives
 186         std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor2D(drawinglayer::processor2d::createPixelProcessor2DFromOutputDevice(
 187             *pVirtualDevice,
 188             aNewViewInformation2D));
 189
 190         drawinglayer::primitive2d::Primitive2DContainer aSequence(2);
 191
 192         aSequence[0] = aGradientPrimitive;
 193         aSequence[1] = aBlackRectanglePrimitive;
 194
 195         pProcessor2D->process(aSequence);
 196         pProcessor2D.reset();
 197
 198         // get result bitmap and scale
 199         aRetval = pVirtualDevice->GetBitmapEx(Point(0, 0), pVirtualDevice->GetOutputSizePixel());
 200     }
 201
 202     return aRetval;
 203 }
 204
 205 BitmapEx XGradientList::CreateBitmapForUI(tools::Long nIndex)
 206 {
 207     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 208     const Size& rSize = rStyleSettings.GetListBoxPreviewDefaultPixelSize();
 209     return CreateBitmap(nIndex, rSize);
 210 }
 211
 212 BitmapEx XGradientList::GetBitmapForPreview(tools::Long nIndex, const Size& rSize)
 213 {
 214     return CreateBitmap(nIndex, rSize);
 215 }
 216
 217 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */