svx/source/tbxctrls/grafctrl.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 <sal/config.h>
  21
  22 #include <comphelper/propertyvalue.hxx>
  23 #include <o3tl/string_view.hxx>
  24 #include <vcl/toolbox.hxx>
  25 #include <svl/intitem.hxx>
  26 #include <svl/itempool.hxx>
  27 #include <svl/eitem.hxx>
  28 #include <svl/whiter.hxx>
  29 #include <sfx2/viewsh.hxx>
  30 #include <sfx2/request.hxx>
  31 #include <sfx2/basedlgs.hxx>
  32 #include <vcl/InterimItemWindow.hxx>
  33 #include <sfx2/sfxdlg.hxx>
  34 #include <tools/urlobj.hxx>
  35
  36 #include <svx/dialogs.hrc>
  37 #include <svx/svxids.hrc>
  38 #include <svx/strings.hrc>
  39 #include <editeng/brushitem.hxx>
  40 #include <editeng/sizeitem.hxx>
  41 #include <svx/sdgcpitm.hxx>
  42
  43 #include <svx/dialmgr.hxx>
  44 #include <svx/svdview.hxx>
  45 #include <svx/svdmodel.hxx>
  46 #include <svx/svdograf.hxx>
  47 #include <svx/svdundo.hxx>
  48 #include <svx/svdtrans.hxx>
  49 #include <svx/grafctrl.hxx>
  50 #include <svx/tbxcolor.hxx>
  51 #include <sdgcoitm.hxx>
  52 #include <svx/sdggaitm.hxx>
  53 #include <svx/sdgluitm.hxx>
  54 #include <svx/sdgmoitm.hxx>
  55 #include <sdgtritm.hxx>
  56 #include <bitmaps.hlst>
  57
  58 #include <com/sun/star/frame/XDispatchProvider.hpp>
  59
  60 using namespace ::com::sun::star::uno;
  61 using namespace ::com::sun::star::frame;
  62 using namespace ::com::sun::star::beans;
  63
  64 constexpr OUString TOOLBOX_NAME = u"colorbar"_ustr;
  65 #define RID_SVXSTR_UNDO_GRAFCROP    RID_SVXSTR_GRAFCROP
  66
  67 namespace {
  68
  69 class ImplGrafControl final : public InterimItemWindow
  70 {
  71 private:
  72     OUString maCommand;
  73     Reference<XFrame> mxFrame;
  74     std::unique_ptr<weld::Image> mxImage;
  75     std::unique_ptr<weld::MetricSpinButton> mxField;
  76
  77     DECL_LINK(ValueChangedHdl, weld::MetricSpinButton&, void);
  78     DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
  79     void ImplModify();
  80
  81 public:
  82     ImplGrafControl( vcl::Window* pParent, const OUString& rCmd, const Reference< XFrame >& rFrame );
  83     virtual ~ImplGrafControl() override;
  84     virtual void            dispose() override;
  85
  86     void Update( const SfxPoolItem* pItem );
  87     void set_field_text(const OUString& rStr) { mxField->set_text(rStr); }
  88     void set_sensitive(bool bSensitive)
  89     {
  90         Enable(bSensitive);
  91         mxImage->set_sensitive(bSensitive);
  92         mxField->set_sensitive(bSensitive);
  93     }
  94 };
  95
  96 }
  97
  98 IMPL_LINK_NOARG(ImplGrafControl, ValueChangedHdl, weld::MetricSpinButton&, void)
  99 {
 100     ImplModify();
 101 }
 102
 103 void ImplGrafControl::ImplModify()
 104 {
 105     const sal_Int64 nVal = mxField->get_value(FieldUnit::NONE);
 106
 107     // Convert value to an any to be usable with dispatch API
 108     Any a;
 109     if ( maCommand == ".uno:GrafRed" ||
 110          maCommand == ".uno:GrafGreen" ||
 111          maCommand == ".uno:GrafBlue" ||
 112          maCommand == ".uno:GrafLuminance" ||
 113          maCommand == ".uno:GrafContrast" )
 114         a <<= sal_Int16( nVal );
 115     else if ( maCommand == ".uno:GrafGamma" ||
 116               maCommand == ".uno:GrafTransparence" )
 117         a <<= sal_Int32( nVal );
 118
 119     if ( !a.hasValue() )
 120         return;
 121
 122     INetURLObject aObj( maCommand );
 123
 124     Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(aObj.GetURLPath(), a) };
 125
 126     SfxToolBoxControl::Dispatch(
 127         Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
 128         maCommand,
 129         aArgs );
 130 }
 131
 132 void ImplGrafControl::Update( const SfxPoolItem* pItem )
 133 {
 134     if( pItem )
 135     {
 136         tools::Long nValue;
 137
 138         if ( maCommand == ".uno:GrafTransparence" )
 139             nValue = static_cast<const SfxUInt16Item*>( pItem )->GetValue();
 140         else if ( maCommand == ".uno:GrafGamma" )
 141             nValue = static_cast<const SfxUInt32Item*>( pItem )->GetValue();
 142         else
 143             nValue = static_cast<const SfxInt16Item*>( pItem )->GetValue();
 144
 145         mxField->set_value(nValue, FieldUnit::NONE);
 146     }
 147     else
 148         mxField->set_text(OUString());
 149 }
 150
 151 namespace {
 152
 153 struct CommandToRID
 154 {
 155     const char* pCommand;
 156     OUString sResId;
 157 };
 158
 159 }
 160
 161 static OUString ImplGetRID( std::u16string_view aCommand )
 162 {
 163     static constexpr CommandToRID aImplCommandToResMap[] =
 164     {
 165         { ".uno:GrafRed",           RID_SVXBMP_GRAF_RED             },
 166         { ".uno:GrafGreen",         RID_SVXBMP_GRAF_GREEN           },
 167         { ".uno:GrafBlue",          RID_SVXBMP_GRAF_BLUE            },
 168         { ".uno:GrafLuminance",     RID_SVXBMP_GRAF_LUMINANCE       },
 169         { ".uno:GrafContrast",      RID_SVXBMP_GRAF_CONTRAST        },
 170         { ".uno:GrafGamma",         RID_SVXBMP_GRAF_GAMMA           },
 171         { ".uno:GrafTransparence",  RID_SVXBMP_GRAF_TRANSPARENCE    },
 172         { nullptr, EMPTY_OUSTRING }
 173     };
 174
 175     OUString sRID;
 176
 177     sal_Int32 i( 0 );
 178     while ( aImplCommandToResMap[ i ].pCommand )
 179     {
 180         if ( o3tl::equalsAscii( aCommand, aImplCommandToResMap[ i ].pCommand ))
 181         {
 182             sRID = aImplCommandToResMap[i].sResId;
 183             break;
 184         }
 185         ++i;
 186     }
 187
 188     return sRID;
 189 }
 190
 191 ImplGrafControl::ImplGrafControl(
 192     vcl::Window* pParent,
 193     const OUString& rCmd,
 194     const Reference< XFrame >& rFrame)
 195     : InterimItemWindow(pParent, u"svx/ui/grafctrlbox.ui"_ustr, u"GrafCtrlBox"_ustr)
 196     , maCommand(rCmd)
 197     , mxFrame(rFrame)
 198     , mxImage(m_xBuilder->weld_image(u"image"_ustr))
 199     , mxField(m_xBuilder->weld_metric_spin_button(u"spinfield"_ustr, FieldUnit::NONE))
 200 {
 201     InitControlBase(&mxField->get_widget());
 202
 203     OUString sResId(ImplGetRID(rCmd));
 204     mxImage->set_from_icon_name(sResId);
 205     mxImage->set_toolbar_background();
 206
 207     SetBackground( Wallpaper() ); // transparent background
 208
 209     mxField->set_help_id(rCmd);
 210     mxField->get_widget().connect_key_press(LINK(this, ImplGrafControl, KeyInputHdl));
 211     mxField->connect_value_changed(LINK(this, ImplGrafControl, ValueChangedHdl));
 212
 213     if (maCommand == ".uno:GrafGamma")
 214     {
 215         mxField->set_digits(2);
 216
 217         mxField->set_range(10, 1000, FieldUnit::NONE);
 218         mxField->set_increments(10, 100, FieldUnit::NONE);
 219     }
 220     else
 221     {
 222         const tools::Long nMinVal = maCommand == ".uno:GrafTransparence" ? 0 : -100;
 223
 224         mxField->set_unit(FieldUnit::PERCENT);
 225         mxField->set_digits(0);
 226
 227         mxField->set_range(nMinVal, 100, FieldUnit::PERCENT);
 228         mxField->set_increments(1, 10, FieldUnit::PERCENT);
 229     }
 230
 231     SetSizePixel(m_xContainer->get_preferred_size());
 232 }
 233
 234 IMPL_LINK(ImplGrafControl, KeyInputHdl, const KeyEvent&, rKEvt, bool)
 235 {
 236     return ChildKeyInput(rKEvt);
 237 }
 238
 239 ImplGrafControl::~ImplGrafControl()
 240 {
 241     disposeOnce();
 242 }
 243
 244 void ImplGrafControl::dispose()
 245 {
 246     mxImage.reset();
 247     mxField.reset();
 248     InterimItemWindow::dispose();
 249 }
 250
 251 namespace {
 252
 253 class ImplGrafModeControl final : public InterimItemWindow
 254 {
 255 private:
 256     sal_uInt16 mnCurPos;
 257     Reference< XFrame > mxFrame;
 258     std::unique_ptr<weld::ComboBox> m_xWidget;
 259
 260     DECL_LINK(SelectHdl, weld::ComboBox&, void);
 261     DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
 262     DECL_LINK(FocusInHdl, weld::Widget&, void);
 263
 264     static void     ImplReleaseFocus();
 265
 266 public:
 267     ImplGrafModeControl( vcl::Window* pParent, const Reference< XFrame >& rFrame );
 268     virtual void dispose() override;
 269     virtual ~ImplGrafModeControl() override;
 270
 271     void set_sensitive(bool bSensitive)
 272     {
 273         Enable(bSensitive);
 274         m_xWidget->set_sensitive(true);
 275     }
 276
 277     void set_active(int nActive)
 278     {
 279         m_xWidget->set_active(nActive);
 280     }
 281
 282     void            Update( const SfxPoolItem* pItem );
 283 };
 284
 285 }
 286
 287 ImplGrafModeControl::ImplGrafModeControl(vcl::Window* pParent, const Reference<XFrame>& rFrame)
 288     : InterimItemWindow(pParent, u"svx/ui/grafmodebox.ui"_ustr, u"GrafModeBox"_ustr)
 289     , mnCurPos(0)
 290     , mxFrame(rFrame)
 291     , m_xWidget(m_xBuilder->weld_combo_box(u"grafmode"_ustr))
 292 {
 293     InitControlBase(m_xWidget.get());
 294
 295     m_xWidget->append_text( SvxResId( RID_SVXSTR_GRAFMODE_STANDARD  ) );
 296     m_xWidget->append_text( SvxResId( RID_SVXSTR_GRAFMODE_GREYS     ) );
 297     m_xWidget->append_text( SvxResId( RID_SVXSTR_GRAFMODE_MONO      ) );
 298     m_xWidget->append_text( SvxResId( RID_SVXSTR_GRAFMODE_WATERMARK ) );
 299
 300     m_xWidget->connect_changed(LINK(this, ImplGrafModeControl, SelectHdl));
 301     m_xWidget->connect_key_press(LINK(this, ImplGrafModeControl, KeyInputHdl));
 302     m_xWidget->connect_focus_in(LINK(this, ImplGrafModeControl, FocusInHdl));
 303
 304     SetSizePixel(m_xWidget->get_preferred_size());
 305 }
 306
 307 void ImplGrafModeControl::dispose()
 308 {
 309     m_xWidget.reset();
 310     InterimItemWindow::dispose();
 311 }
 312
 313 ImplGrafModeControl::~ImplGrafModeControl()
 314 {
 315     disposeOnce();
 316 }
 317
 318 IMPL_LINK(ImplGrafModeControl, SelectHdl, weld::ComboBox&, rBox, void)
 319 {
 320     Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(u"GrafMode"_ustr,
 321                                                                    sal_Int16(rBox.get_active())) };
 322
 323     /*  #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
 324         This instance may be deleted in the meantime (i.e. when a dialog is opened
 325         while in Dispatch()), accessing members will crash in this case. */
 326     ImplReleaseFocus();
 327
 328     SfxToolBoxControl::Dispatch(
 329         Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
 330         u".uno:GrafMode"_ustr,
 331         aArgs );
 332 }
 333
 334 IMPL_LINK(ImplGrafModeControl, KeyInputHdl, const KeyEvent&, rKEvt, bool)
 335 {
 336     bool bHandled(false);
 337
 338     if (rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE)
 339     {
 340         m_xWidget->set_active(mnCurPos);
 341         ImplReleaseFocus();
 342         bHandled = true;
 343     }
 344
 345     return bHandled || ChildKeyInput(rKEvt);
 346 }
 347
 348 IMPL_LINK_NOARG(ImplGrafModeControl, FocusInHdl, weld::Widget&, void)
 349 {
 350     mnCurPos = m_xWidget->get_active();
 351 }
 352
 353 void ImplGrafModeControl::ImplReleaseFocus()
 354 {
 355     if (const SfxViewShell* pViewShell = SfxViewShell::Current())
 356     {
 357         vcl::Window* pShellWnd = pViewShell->GetWindow();
 358
 359         if( pShellWnd )
 360             pShellWnd->GrabFocus();
 361     }
 362 }
 363
 364 void ImplGrafModeControl::Update( const SfxPoolItem* pItem )
 365 {
 366     if( pItem )
 367         m_xWidget->set_active(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
 368     else
 369         m_xWidget->set_active(-1);
 370 }
 371
 372 SvxGrafToolBoxControl::SvxGrafToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx) :
 373     SfxToolBoxControl( nSlotId, nId, rTbx )
 374 {
 375     rTbx.SetItemBits( nId, ToolBoxItemBits::DROPDOWN | rTbx.GetItemBits( nId ) );
 376     rTbx.Invalidate();
 377 }
 378
 379 SvxGrafToolBoxControl::~SvxGrafToolBoxControl()
 380 {
 381 }
 382
 383 void SvxGrafToolBoxControl::StateChangedAtToolBoxControl( sal_uInt16, SfxItemState eState, const SfxPoolItem* pState )
 384 {
 385     ImplGrafControl* pCtrl = static_cast<ImplGrafControl*>( GetToolBox().GetItemWindow( GetId() ) );
 386     DBG_ASSERT( pCtrl, "Control not found" );
 387
 388     if( eState == SfxItemState::DISABLED )
 389     {
 390         pCtrl->set_sensitive(false);
 391         pCtrl->set_field_text( OUString() );
 392     }
 393     else
 394     {
 395         pCtrl->set_sensitive(true);
 396
 397         if( eState == SfxItemState::DEFAULT )
 398             pCtrl->Update( pState );
 399         else
 400             pCtrl->Update( nullptr );
 401     }
 402 }
 403
 404 VclPtr<InterimItemWindow> SvxGrafToolBoxControl::CreateItemWindow( vcl::Window *pParent )
 405 {
 406     return VclPtr<ImplGrafControl>::Create( pParent, m_aCommandURL, m_xFrame ).get();
 407 }
 408
 409 SFX_IMPL_TOOLBOX_CONTROL( SvxGrafRedToolBoxControl, SfxInt16Item );
 410
 411 SvxGrafRedToolBoxControl::SvxGrafRedToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) :
 412     SvxGrafToolBoxControl( nSlotId, nId, rTbx )
 413 {
 414 }
 415
 416 SFX_IMPL_TOOLBOX_CONTROL( SvxGrafGreenToolBoxControl, SfxInt16Item );
 417
 418 SvxGrafGreenToolBoxControl::SvxGrafGreenToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) :
 419     SvxGrafToolBoxControl( nSlotId, nId, rTbx )
 420 {
 421 }
 422
 423 SFX_IMPL_TOOLBOX_CONTROL( SvxGrafBlueToolBoxControl, SfxInt16Item );
 424
 425 SvxGrafBlueToolBoxControl::SvxGrafBlueToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) :
 426     SvxGrafToolBoxControl( nSlotId, nId, rTbx )
 427 {
 428 }
 429
 430 SFX_IMPL_TOOLBOX_CONTROL( SvxGrafLuminanceToolBoxControl, SfxInt16Item );
 431
 432 SvxGrafLuminanceToolBoxControl::SvxGrafLuminanceToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) :
 433     SvxGrafToolBoxControl( nSlotId, nId, rTbx )
 434 {
 435 }
 436
 437 SFX_IMPL_TOOLBOX_CONTROL( SvxGrafContrastToolBoxControl, SfxInt16Item );
 438
 439 SvxGrafContrastToolBoxControl::SvxGrafContrastToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) :
 440     SvxGrafToolBoxControl( nSlotId, nId, rTbx )
 441 {
 442 }
 443
 444 SFX_IMPL_TOOLBOX_CONTROL( SvxGrafGammaToolBoxControl, SfxUInt32Item );
 445
 446 SvxGrafGammaToolBoxControl::SvxGrafGammaToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) :
 447     SvxGrafToolBoxControl( nSlotId, nId, rTbx )
 448 {
 449 }
 450
 451 SFX_IMPL_TOOLBOX_CONTROL( SvxGrafTransparenceToolBoxControl, SfxUInt16Item );
 452
 453 SvxGrafTransparenceToolBoxControl::SvxGrafTransparenceToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) :
 454     SvxGrafToolBoxControl( nSlotId, nId, rTbx )
 455 {
 456 }
 457
 458 SFX_IMPL_TOOLBOX_CONTROL( SvxGrafModeToolBoxControl, SfxUInt16Item );
 459
 460 SvxGrafModeToolBoxControl::SvxGrafModeToolBoxControl( sal_uInt16 nSlotId, ToolBoxItemId nId, ToolBox& rTbx ) :
 461     SfxToolBoxControl( nSlotId, nId, rTbx )
 462 {
 463 }
 464
 465 SvxGrafModeToolBoxControl::~SvxGrafModeToolBoxControl()
 466 {
 467 }
 468
 469 void SvxGrafModeToolBoxControl::StateChangedAtToolBoxControl( sal_uInt16, SfxItemState eState, const SfxPoolItem* pState )
 470
 471 {
 472     ImplGrafModeControl* pCtrl = static_cast<ImplGrafModeControl*>( GetToolBox().GetItemWindow( GetId() ) );
 473     DBG_ASSERT( pCtrl, "Control not found" );
 474
 475     if( eState == SfxItemState::DISABLED )
 476     {
 477         pCtrl->set_sensitive(false);
 478         pCtrl->set_active(-1);
 479     }
 480     else
 481     {
 482         pCtrl->set_sensitive(true);
 483
 484         if( eState == SfxItemState::DEFAULT )
 485             pCtrl->Update( pState );
 486         else
 487             pCtrl->Update( nullptr );
 488     }
 489 }
 490
 491 VclPtr<InterimItemWindow> SvxGrafModeToolBoxControl::CreateItemWindow( vcl::Window *pParent )
 492 {
 493     return VclPtr<ImplGrafModeControl>::Create( pParent, m_xFrame ).get();
 494 }
 495
 496 void SvxGrafAttrHelper::ExecuteGrafAttr( SfxRequest& rReq, SdrView& rView )
 497 {
 498     SfxItemPool&    rPool = rView.GetModel().GetItemPool();
 499     SfxItemSetFixed<SDRATTR_GRAF_FIRST, SDRATTR_GRAF_LAST> aSet( rPool );
 500     OUString        aUndoStr;
 501     const bool      bUndo = rView.IsUndoEnabled();
 502
 503     if( bUndo )
 504     {
 505         aUndoStr = rView.GetMarkedObjectList().GetMarkDescription() + " ";
 506     }
 507
 508     const SfxItemSet*   pArgs = rReq.GetArgs();
 509     const SfxPoolItem*  pItem;
 510     sal_uInt16              nSlot = rReq.GetSlot();
 511
 512     if( !pArgs || SfxItemState::SET != pArgs->GetItemState( nSlot, false, &pItem ))
 513         pItem = nullptr;
 514
 515     switch( nSlot )
 516     {
 517         case SID_ATTR_GRAF_RED:
 518         {
 519             if( pItem )
 520             {
 521                 aSet.Put( SdrGrafRedItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
 522                 if( bUndo )
 523                     aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFRED );
 524             }
 525         }
 526         break;
 527
 528         case SID_ATTR_GRAF_GREEN:
 529         {
 530             if( pItem )
 531             {
 532                 aSet.Put( SdrGrafGreenItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
 533                 if( bUndo )
 534                     aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFGREEN );
 535             }
 536         }
 537         break;
 538
 539         case SID_ATTR_GRAF_BLUE:
 540         {
 541             if( pItem )
 542             {
 543                 aSet.Put( SdrGrafBlueItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
 544                 if( bUndo )
 545                     aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFBLUE );
 546             }
 547         }
 548         break;
 549
 550         case SID_ATTR_GRAF_LUMINANCE:
 551         {
 552             if( pItem )
 553             {
 554                 aSet.Put( SdrGrafLuminanceItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
 555                 if( bUndo )
 556                     aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFLUMINANCE );
 557             }
 558         }
 559         break;
 560
 561         case SID_ATTR_GRAF_CONTRAST:
 562         {
 563             if( pItem )
 564             {
 565                 aSet.Put( SdrGrafContrastItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
 566                 if( bUndo )
 567                     aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFCONTRAST );
 568             }
 569         }
 570         break;
 571
 572         case SID_ATTR_GRAF_GAMMA:
 573         {
 574             if( pItem )
 575             {
 576                 aSet.Put( SdrGrafGamma100Item( static_cast<const SfxUInt32Item*>(pItem)->GetValue() ));
 577                 if( bUndo )
 578                     aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFGAMMA );
 579             }
 580         }
 581         break;
 582
 583         case SID_ATTR_GRAF_TRANSPARENCE:
 584         {
 585             if( pItem )
 586             {
 587                 aSet.Put( SdrGrafTransparenceItem( static_cast<const SfxUInt16Item*>(pItem)->GetValue() ));
 588                 if( bUndo )
 589                     aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFTRANSPARENCY );
 590             }
 591         }
 592         break;
 593
 594         case SID_ATTR_GRAF_MODE:
 595         {
 596             if( pItem )
 597             {
 598                 aSet.Put( SdrGrafModeItem( static_cast<GraphicDrawMode>(static_cast<const SfxUInt16Item*>(pItem)->GetValue()) ));
 599                 if( bUndo )
 600                     aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFMODE );
 601             }
 602         }
 603         break;
 604
 605         case SID_ATTR_GRAF_CROP:
 606         {
 607             const SdrMarkList& rMarkList = rView.GetMarkedObjectList();
 608
 609             if( 0 < rMarkList.GetMarkCount() )
 610             {
 611                 SdrGrafObj* pObj = static_cast<SdrGrafObj*>( rMarkList.GetMark( 0 )->GetMarkedSdrObj() );
 612
 613                 if( ( pObj->GetGraphicType() != GraphicType::NONE ) &&
 614                     ( pObj->GetGraphicType() != GraphicType::Default ) )
 615                 {
 616                     SfxItemSetFixed<SDRATTR_GRAFCROP, SDRATTR_GRAFCROP> aGrfAttr( rPool );
 617                     const MapUnit       eOldMetric = rPool.GetMetric( 0 );
 618
 619                     aGrfAttr.Put(pObj->GetMergedItemSet());
 620                     rPool.SetDefaultMetric( MapUnit::MapTwip );
 621
 622                     SfxItemSetFixed<
 623                             SDRATTR_GRAFCROP, SDRATTR_GRAFCROP,
 624                             SID_ATTR_PAGE_SIZE, SID_ATTR_PAGE_SIZE,
 625                             SID_ATTR_GRAF_CROP, SID_ATTR_GRAF_FRMSIZE,
 626                             SID_ATTR_GRAF_GRAPHIC, SID_ATTR_GRAF_GRAPHIC>
 627                         aCropDlgAttr(rPool);
 628
 629                     aCropDlgAttr.Put( SvxBrushItem( pObj->GetGraphic(), GPOS_MM, SID_ATTR_GRAF_GRAPHIC ) );
 630                     aCropDlgAttr.Put( SvxSizeItem( SID_ATTR_PAGE_SIZE,
 631                             o3tl::convert(Size(200000, 200000), o3tl::Length::mm100, o3tl::Length::twip)));
 632                     aCropDlgAttr.Put( SvxSizeItem( SID_ATTR_GRAF_FRMSIZE,
 633                             o3tl::convert(pObj->GetLogicRect().GetSize(), o3tl::Length::mm100, o3tl::Length::twip)));
 634
 635                     const SdrGrafCropItem&  rCrop = aGrfAttr.Get( SDRATTR_GRAFCROP );
 636                     Size aLTSize = o3tl::convert(Size(rCrop.GetLeft(), rCrop.GetTop()), o3tl::Length::mm100, o3tl::Length::twip);
 637                     Size aRBSize = o3tl::convert(Size(rCrop.GetRight(), rCrop.GetBottom()), o3tl::Length::mm100, o3tl::Length::twip);
 638
 639                     aCropDlgAttr.Put( SdrGrafCropItem( aLTSize.Width(), aLTSize.Height(),
 640                                                     aRBSize.Width(), aRBSize.Height() ) );
 641
 642                     SfxViewShell* pCurrentSh = SfxViewShell::Current();
 643                     vcl::Window* pParent(pCurrentSh ? pCurrentSh->GetWindow() : nullptr);
 644                     SfxSingleTabDialogController aCropDialog(pParent ? pParent->GetFrameWeld() : nullptr,
 645                         &aCropDlgAttr);
 646                     const OUString aCropStr(SvxResId(RID_SVXSTR_GRAFCROP));
 647
 648                     SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
 649                     ::CreateTabPage fnCreatePage = pFact->GetTabPageCreatorFunc( RID_SVXPAGE_GRFCROP );
 650                     std::unique_ptr<SfxTabPage> xTabPage = (*fnCreatePage)(aCropDialog.get_content_area(), &aCropDialog, &aCropDlgAttr);
 651                     sal_Int32 nPreferredDPI = rView.getSdrModelFromSdrView().getImagePreferredDPI();
 652                     xTabPage->getAdditionalProperties().emplace("PreferredDPI", css::uno::Any(nPreferredDPI));
 653                     xTabPage->SetPageTitle(aCropStr);
 654                     aCropDialog.SetTabPage(std::move(xTabPage));
 655
 656                     if (aCropDialog.run() == RET_OK)
 657                     {
 658                         const SfxItemSet* pOutAttr = aCropDialog.GetOutputItemSet();
 659
 660                         if( pOutAttr )
 661                         {
 662                             aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFCROP );
 663
 664                             // set crop attributes
 665                             if( SfxItemState::SET <= pOutAttr->GetItemState( SDRATTR_GRAFCROP ) )
 666                             {
 667                                 const SdrGrafCropItem& rNewCrop = pOutAttr->Get( SDRATTR_GRAFCROP );
 668
 669                                 aLTSize = o3tl::convert(Size(rNewCrop.GetLeft(), rNewCrop.GetTop()), o3tl::Length::twip, o3tl::Length::mm100);
 670                                 aRBSize = o3tl::convert(Size(rNewCrop.GetRight(), rNewCrop.GetBottom()), o3tl::Length::twip, o3tl::Length::mm100);
 671                                 aSet.Put( SdrGrafCropItem( aLTSize.Width(), aLTSize.Height(), aRBSize.Width(), aRBSize.Height() ) );
 672                             }
 673
 674                             // set new logic rect
 675                             if( SfxItemState::SET <= pOutAttr->GetItemState( SID_ATTR_GRAF_FRMSIZE ) )
 676                             {
 677                                 Point       aNewOrigin( pObj->GetLogicRect().TopLeft() );
 678                                 const Size& rGrfSize = pOutAttr->Get( SID_ATTR_GRAF_FRMSIZE ).GetSize();
 679                                 Size aNewGrfSize = o3tl::convert(rGrfSize, o3tl::Length::twip, o3tl::Length::mm100);
 680                                 Size        aOldGrfSize( pObj->GetLogicRect().GetSize() );
 681
 682                                 tools::Rectangle aNewRect( aNewOrigin, aNewGrfSize );
 683                                 Point aOffset( (aNewGrfSize.Width() - aOldGrfSize.Width()) >> 1,
 684                                             (aNewGrfSize.Height() - aOldGrfSize.Height()) >> 1 );
 685
 686                                 // #106181# rotate snap rect before setting it
 687                                 const GeoStat& aGeo = pObj->GetGeoStat();
 688
 689                                 if (aGeo.m_nRotationAngle || aGeo.m_nShearAngle)
 690                                 {
 691                                     tools::Polygon aPol(aNewRect);
 692
 693                                     // also transform origin offset
 694                                     if (aGeo.m_nShearAngle)
 695                                     {
 696                                         ShearPoly(aPol,
 697                                                 aNewRect.TopLeft(),
 698                                                 aGeo.mfTanShearAngle);
 699                                         ShearPoint(aOffset, Point(0,0), aGeo.mfTanShearAngle);
 700                                     }
 701                                     if (aGeo.m_nRotationAngle)
 702                                     {
 703                                         RotatePoly(aPol,
 704                                                 aNewRect.TopLeft(),
 705                                                 aGeo.mfSinRotationAngle,aGeo.mfCosRotationAngle);
 706                                         RotatePoint(aOffset, Point(0,0), aGeo.mfSinRotationAngle,aGeo.mfCosRotationAngle);
 707                                     }
 708
 709                                     // apply offset
 710                                     aPol.Move( -aOffset.X(), -aOffset.Y() );
 711                                     aNewRect=aPol.GetBoundRect();
 712                                 }
 713                                 else
 714                                 {
 715                                     aNewRect.Move( -aOffset.X(), -aOffset.Y() );
 716                                 }
 717
 718                                 if( !aSet.Count() )
 719                                     rView.SetMarkedObjRect( aNewRect );
 720                                 else
 721                                 {
 722                                     if( bUndo )
 723                                     {
 724                                         rView.BegUndo( aUndoStr );
 725                                         rView.AddUndo(rView.GetModel().GetSdrUndoFactory().CreateUndoGeoObject(*pObj));
 726                                     }
 727                                     pObj->SetSnapRect( aNewRect );
 728                                     rView.SetAttributes( aSet );
 729
 730                                     if( bUndo )
 731                                         rView.EndUndo();
 732                                     aSet.ClearItem();
 733                                 }
 734                             }
 735                         }
 736                     }
 737
 738                     rPool.SetDefaultMetric( eOldMetric );
 739                 }
 740             }
 741         }
 742         break;
 743
 744         case SID_COLOR_SETTINGS:
 745         {
 746             svx::ToolboxAccess aToolboxAccess( TOOLBOX_NAME );
 747             aToolboxAccess.toggleToolbox();
 748             rReq.Done();
 749             break;
 750         }
 751
 752         default:
 753             break;
 754     }
 755
 756     if( aSet.Count() )
 757     {
 758         if( bUndo )
 759             rView.BegUndo( aUndoStr );
 760
 761         rView.SetAttributes( aSet );
 762
 763         if( bUndo )
 764             rView.EndUndo();
 765     }
 766 }
 767
 768 void SvxGrafAttrHelper::GetGrafAttrState( SfxItemSet& rSet, SdrView const & rView )
 769 {
 770     SfxItemPool&    rPool = rView.GetModel().GetItemPool();
 771     SfxItemSet      aAttrSet( rPool );
 772     SfxWhichIter    aIter( rSet );
 773     sal_uInt16      nWhich = aIter.FirstWhich();
 774     const           SdrMarkList& rMarkList = rView.GetMarkedObjectList();
 775     bool            bEnableColors = true;
 776     bool            bEnableTransparency = true;
 777     bool            bEnableCrop = ( 1 == rMarkList.GetMarkCount() );
 778
 779     for( size_t i = 0, nCount = rMarkList.GetMarkCount(); i < nCount; ++i )
 780     {
 781         SdrGrafObj* pGrafObj = dynamic_cast< SdrGrafObj* >( rMarkList.GetMark( i )->GetMarkedSdrObj() );
 782
 783         if( !pGrafObj ||
 784             ( pGrafObj->GetGraphicType() == GraphicType::NONE ) ||
 785             ( pGrafObj->GetGraphicType() == GraphicType::Default  ))
 786         {
 787             bEnableColors = bEnableTransparency = bEnableCrop = false;
 788             break;
 789         }
 790         else if( bEnableTransparency && ( pGrafObj->HasGDIMetaFile() || pGrafObj->IsAnimated() ) )
 791         {
 792             bEnableTransparency = false;
 793         }
 794     }
 795
 796     rView.GetAttributes( aAttrSet );
 797
 798     while( nWhich )
 799     {
 800         sal_uInt16 nSlotId = SfxItemPool::IsWhich( nWhich ) ? rPool.GetSlotId( nWhich ) : nWhich;
 801
 802         switch( nSlotId )
 803         {
 804             case SID_ATTR_GRAF_MODE:
 805             {
 806                 if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFMODE ) )
 807                 {
 808                     if( bEnableColors )
 809                     {
 810                         rSet.Put( SfxUInt16Item( nSlotId,
 811                             sal::static_int_cast< sal_uInt16 >( aAttrSet.Get(SDRATTR_GRAFMODE).GetValue() ) ) );
 812                     }
 813                     else
 814                     {
 815                         rSet.DisableItem( SID_ATTR_GRAF_MODE );
 816                     }
 817                 }
 818             }
 819             break;
 820
 821             case SID_ATTR_GRAF_RED:
 822             {
 823                 if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFRED ) )
 824                 {
 825                     if( bEnableColors )
 826                     {
 827                         rSet.Put( SfxInt16Item( nSlotId, aAttrSet.Get(SDRATTR_GRAFRED).GetValue() ) );
 828                     }
 829                     else
 830                     {
 831                         rSet.DisableItem( SID_ATTR_GRAF_RED );
 832                     }
 833                 }
 834             }
 835             break;
 836
 837             case SID_ATTR_GRAF_GREEN:
 838             {
 839                 if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFGREEN ) )
 840                 {
 841                     if( bEnableColors )
 842                     {
 843                         rSet.Put( SfxInt16Item( nSlotId, aAttrSet.Get(SDRATTR_GRAFGREEN).GetValue()) );
 844                     }
 845                     else
 846                     {
 847                         rSet.DisableItem( SID_ATTR_GRAF_GREEN );
 848                     }
 849                 }
 850             }
 851             break;
 852
 853             case SID_ATTR_GRAF_BLUE:
 854             {
 855                 if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFBLUE ) )
 856                 {
 857                     if( bEnableColors )
 858                     {
 859                         rSet.Put( SfxInt16Item( nSlotId, aAttrSet.Get(SDRATTR_GRAFBLUE).GetValue()) );
 860                     }
 861                     else
 862                     {
 863                         rSet.DisableItem( SID_ATTR_GRAF_BLUE );
 864                     }
 865                 }
 866             }
 867             break;
 868
 869             case SID_ATTR_GRAF_LUMINANCE:
 870             {
 871                 if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFLUMINANCE ) )
 872                 {
 873                     if( bEnableColors )
 874                     {
 875                         rSet.Put( SfxInt16Item( nSlotId, aAttrSet.Get(SDRATTR_GRAFLUMINANCE).GetValue()) );
 876                     }
 877                     else
 878                     {
 879                         rSet.DisableItem( SID_ATTR_GRAF_LUMINANCE );
 880                     }
 881                 }
 882             }
 883             break;
 884
 885             case SID_ATTR_GRAF_CONTRAST:
 886             {
 887                 if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFCONTRAST ) )
 888                 {
 889                     if( bEnableColors )
 890                     {
 891                         rSet.Put( SfxInt16Item( nSlotId,
 892                             aAttrSet.Get(SDRATTR_GRAFCONTRAST).GetValue()) );
 893                     }
 894                     else
 895                     {
 896                         rSet.DisableItem( SID_ATTR_GRAF_CONTRAST );
 897                     }
 898                 }
 899             }
 900             break;
 901
 902             case SID_ATTR_GRAF_GAMMA:
 903             {
 904                 if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFGAMMA ) )
 905                 {
 906                     if( bEnableColors )
 907                     {
 908                         rSet.Put( SfxUInt32Item( nSlotId,
 909                             aAttrSet.Get(SDRATTR_GRAFGAMMA).GetValue() ) );
 910                     }
 911                     else
 912                     {
 913                         rSet.DisableItem( SID_ATTR_GRAF_GAMMA );
 914                     }
 915                 }
 916             }
 917             break;
 918
 919             case SID_ATTR_GRAF_TRANSPARENCE:
 920             {
 921                 if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFTRANSPARENCE ) )
 922                 {
 923                     if( bEnableTransparency )
 924                     {
 925                         rSet.Put( SfxUInt16Item( nSlotId,
 926                             aAttrSet.Get(SDRATTR_GRAFTRANSPARENCE).GetValue() ) );
 927                     }
 928                     else
 929                     {
 930                         rSet.DisableItem( SID_ATTR_GRAF_TRANSPARENCE );
 931                     }
 932                 }
 933             }
 934             break;
 935
 936             case SID_ATTR_GRAF_CROP:
 937             {
 938                 if( !bEnableCrop )
 939                     rSet.DisableItem( nSlotId );
 940             }
 941             break;
 942
 943             case SID_COLOR_SETTINGS :
 944             {
 945                 svx::ToolboxAccess aToolboxAccess( TOOLBOX_NAME );
 946                 rSet.Put( SfxBoolItem( nWhich, aToolboxAccess.isToolboxVisible() ) );
 947                 break;
 948             }
 949
 950             default:
 951             break;
 952         }
 953
 954         nWhich = aIter.NextWhich();
 955     }
 956 }
 957
 958 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */