svx/source/tbxctrls/colrctrl.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 <sot/exchange.hxx>
  23 #include <svx/strings.hrc>
  24 #include <svx/svxids.hrc>
  25
  26 #include <sfx2/viewsh.hxx>
  27 #include <sfx2/objsh.hxx>
  28 #include <sfx2/dispatch.hxx>
  29 #include <sfx2/viewfrm.hxx>
  30 #include <vcl/image.hxx>
  31 #include <vcl/transfer.hxx>
  32
  33 #include <colrctrl.hxx>
  34
  35 #include <svx/svdview.hxx>
  36 #include <svx/drawitem.hxx>
  37 #include <svx/xfillit0.hxx>
  38 #include <svx/xflclit.hxx>
  39 #include <editeng/colritem.hxx>
  40 #include <svx/xlineit0.hxx>
  41 #include <svx/xlnclit.hxx>
  42 #include <svx/xtable.hxx>
  43 #include <svx/dialmgr.hxx>
  44 #include <helpids.h>
  45 #include <vcl/virdev.hxx>
  46
  47 #include <com/sun/star/beans/NamedValue.hpp>
  48
  49 using namespace com::sun::star;
  50
  51 class SvxColorValueSetData final : public TransferDataContainer
  52 {
  53 private:
  54     uno::Sequence<beans::NamedValue> m_Data;
  55
  56     virtual void AddSupportedFormats() override;
  57     virtual bool GetData(const css::datatransfer::DataFlavor& rFlavor, const OUString& rDestDoc) override;
  58
  59 public:
  60     SvxColorValueSetData()
  61     {
  62     }
  63
  64     void SetData(const uno::Sequence<beans::NamedValue>& rData)
  65     {
  66         m_Data = rData;
  67         ClearFormats(); // invalidate m_aAny so new data will take effect
  68     }
  69 };
  70
  71 void SvxColorValueSetData::AddSupportedFormats()
  72 {
  73     AddFormat( SotClipboardFormatId::XFA );
  74 }
  75
  76 bool SvxColorValueSetData::GetData( const css::datatransfer::DataFlavor& rFlavor, const OUString& /*rDestDoc*/ )
  77 {
  78     bool bRet = false;
  79
  80     if( SotExchange::GetFormat( rFlavor ) == SotClipboardFormatId::XFA )
  81     {
  82         SetAny(uno::Any(m_Data));
  83         bRet = true;
  84     }
  85
  86     return bRet;
  87 }
  88
  89 void SvxColorValueSet_docking::SetDrawingArea(weld::DrawingArea* pDrawingArea)
  90 {
  91     SvxColorValueSet::SetDrawingArea(pDrawingArea);
  92     SetAccessibleName(SvxResId(STR_COLORTABLE));
  93     SetStyle(GetStyle() | WB_ITEMBORDER);
  94
  95     m_xHelper.set(new SvxColorValueSetData);
  96     rtl::Reference<TransferDataContainer> xHelper(m_xHelper);
  97     SetDragDataTransferable(xHelper, DND_ACTION_COPY);
  98 }
  99
 100 SvxColorValueSet_docking::SvxColorValueSet_docking(std::unique_ptr<weld::ScrolledWindow> xWindow)
 101     : SvxColorValueSet(std::move(xWindow))
 102     , mbLeftButton(true)
 103 {
 104 }
 105
 106 bool SvxColorValueSet_docking::MouseButtonDown( const MouseEvent& rMEvt )
 107 {
 108     bool bRet;
 109
 110     // For Mac still handle differently!
 111     if( rMEvt.IsLeft() )
 112     {
 113         mbLeftButton = true;
 114         bRet = SvxColorValueSet::MouseButtonDown( rMEvt );
 115     }
 116     else
 117     {
 118         mbLeftButton = false;
 119         MouseEvent aMEvt( rMEvt.GetPosPixel(),
 120                           rMEvt.GetClicks(),
 121                           rMEvt.GetMode(),
 122                           MOUSE_LEFT,
 123                           rMEvt.GetModifier() );
 124         bRet = SvxColorValueSet::MouseButtonDown( aMEvt );
 125     }
 126
 127     return bRet;
 128 }
 129
 130 bool SvxColorValueSet_docking::MouseButtonUp( const MouseEvent& rMEvt )
 131 {
 132     bool bRet;
 133
 134     // For Mac still handle differently!
 135     if( rMEvt.IsLeft() )
 136     {
 137         mbLeftButton = true;
 138         bRet = SvxColorValueSet::MouseButtonUp( rMEvt );
 139     }
 140     else
 141     {
 142         mbLeftButton = false;
 143         MouseEvent aMEvt( rMEvt.GetPosPixel(),
 144                           rMEvt.GetClicks(),
 145                           rMEvt.GetMode(),
 146                           MOUSE_LEFT,
 147                           rMEvt.GetModifier() );
 148         bRet = SvxColorValueSet::MouseButtonUp( aMEvt );
 149     }
 150     SetNoSelection();
 151
 152     return bRet;
 153 }
 154
 155 bool SvxColorValueSet_docking::StartDrag()
 156 {
 157     sal_uInt16 nPos = GetSelectedItemId();
 158     Color aItemColor( GetItemColor( nPos ) );
 159     OUString sItemText( GetItemText( nPos ) );
 160
 161     drawing::FillStyle eStyle = ((1 == nPos)
 162                             ? drawing::FillStyle_NONE
 163                             : drawing::FillStyle_SOLID);
 164
 165     XFillColorItem const color(sItemText, aItemColor);
 166     XFillStyleItem const style(eStyle);
 167     uno::Any c, s;
 168     color.QueryValue(c, 0);
 169     style.QueryValue(s, 0);
 170
 171     uno::Sequence<beans::NamedValue> props{ { "FillColor", std::move(c) },
 172                                             { "FillStyle", std::move(s) } };
 173     m_xHelper->SetData(props);
 174
 175     return false;
 176 }
 177
 178 constexpr sal_uInt16 gnLeftSlot = SID_ATTR_FILL_COLOR;
 179 constexpr sal_uInt16 gnRightSlot = SID_ATTR_LINE_COLOR;
 180
 181 SvxColorDockingWindow::SvxColorDockingWindow(SfxBindings* _pBindings, SfxChildWindow* pCW, vcl::Window* _pParent)
 182     : SfxDockingWindow(_pBindings, pCW, _pParent,
 183         "DockingColorWindow", "svx/ui/dockingcolorwindow.ui")
 184     , xColorSet(new SvxColorValueSet_docking(m_xBuilder->weld_scrolled_window("valuesetwin", true)))
 185     , xColorSetWin(new weld::CustomWeld(*m_xBuilder, "valueset", *xColorSet))
 186 {
 187     SetText(SvxResId(STR_COLORTABLE));
 188     SetQuickHelpText(SvxResId(RID_SVXSTR_COLORBAR));
 189     SetSizePixel(LogicToPixel(Size(150, 22), MapMode(MapUnit::MapAppFont)));
 190     SetHelpId(HID_CTRL_COLOR);
 191
 192     xColorSet->SetSelectHdl( LINK( this, SvxColorDockingWindow, SelectHdl ) );
 193     xColorSet->SetHelpId(HID_COLOR_CTL_COLORS);
 194
 195     // Get the model from the view shell.  Using SfxObjectShell::Current()
 196     // is unreliable when called at the wrong times.
 197     SfxObjectShell* pDocSh = nullptr;
 198     if (_pBindings != nullptr)
 199     {
 200         SfxDispatcher* pDispatcher = _pBindings->GetDispatcher();
 201         if (pDispatcher != nullptr)
 202         {
 203             SfxViewFrame* pFrame = pDispatcher->GetFrame();
 204             if (pFrame != nullptr)
 205             {
 206                 SfxViewShell* pViewShell = pFrame->GetViewShell();
 207                 if (pViewShell != nullptr)
 208                     pDocSh = pViewShell->GetObjectShell();
 209             }
 210         }
 211     }
 212
 213     if ( pDocSh )
 214     {
 215         const SfxPoolItem*  pItem = pDocSh->GetItem( SID_COLOR_TABLE );
 216         if( pItem )
 217         {
 218             pColorList = static_cast<const SvxColorListItem*>(pItem)->GetColorList();
 219             FillValueSet();
 220         }
 221     }
 222
 223     Size aItemSize = xColorSet->CalcItemSizePixel(Size(SvxColorValueSet::getEntryEdgeLength(), SvxColorValueSet::getEntryEdgeLength()));
 224     aItemSize.setWidth( aItemSize.Width() + SvxColorValueSet::getEntryEdgeLength() );
 225     aItemSize.setWidth( aItemSize.Width() / 2 );
 226     aItemSize.setHeight( aItemSize.Height() + SvxColorValueSet::getEntryEdgeLength() );
 227     aItemSize.setHeight( aItemSize.Height() / 2 );
 228
 229     if (_pBindings != nullptr)
 230         StartListening(*_pBindings, DuplicateHandling::Prevent);
 231 }
 232
 233 SvxColorDockingWindow::~SvxColorDockingWindow()
 234 {
 235     disposeOnce();
 236 }
 237
 238 void SvxColorDockingWindow::dispose()
 239 {
 240     EndListening( GetBindings() );
 241     xColorSetWin.reset();
 242     xColorSet.reset();
 243     SfxDockingWindow::dispose();
 244 }
 245
 246 void SvxColorDockingWindow::Notify( SfxBroadcaster& , const SfxHint& rHint )
 247 {
 248     const SfxPoolItemHint* pPoolItemHint = dynamic_cast<const SfxPoolItemHint*>(&rHint);
 249     if ( pPoolItemHint )
 250         if (auto pColorListItem = dynamic_cast<const SvxColorListItem*>(pPoolItemHint->GetObject()))
 251         {
 252             // The list of colors has changed
 253             pColorList = pColorListItem->GetColorList();
 254             FillValueSet();
 255         }
 256 }
 257
 258 void SvxColorDockingWindow::FillValueSet()
 259 {
 260     if( !pColorList.is() )
 261         return;
 262
 263     xColorSet->Clear();
 264
 265     xColorSet->addEntriesForXColorList(*pColorList, 2);
 266
 267     // create the last entry for 'invisible/none'
 268     const Size aColorSize(SvxColorValueSet::getEntryEdgeLength(), SvxColorValueSet::getEntryEdgeLength());
 269     tools::Long nPtX = aColorSize.Width() - 1;
 270     tools::Long nPtY = aColorSize.Height() - 1;
 271     ScopedVclPtrInstance< VirtualDevice > pVD;
 272
 273     pVD->SetOutputSizePixel( aColorSize );
 274     pVD->SetLineColor( COL_BLACK );
 275     pVD->SetBackground( Wallpaper( COL_WHITE ) );
 276     pVD->DrawLine( Point(), Point( nPtX, nPtY ) );
 277     pVD->DrawLine( Point( 0, nPtY ), Point( nPtX, 0 ) );
 278
 279     BitmapEx aBmp( pVD->GetBitmapEx( Point(), aColorSize ) );
 280
 281     xColorSet->InsertItem( sal_uInt16(1), Image(aBmp), SvxResId( RID_SVXSTR_INVISIBLE ) );
 282 }
 283
 284 bool SvxColorDockingWindow::Close()
 285 {
 286     SfxBoolItem aItem( SID_COLOR_CONTROL, false );
 287     GetBindings().GetDispatcher()->ExecuteList(SID_COLOR_CONTROL,
 288             SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, { &aItem });
 289     SfxDockingWindow::Close();
 290     return true;
 291 }
 292
 293 IMPL_LINK_NOARG(SvxColorDockingWindow, SelectHdl, ValueSet*, void)
 294 {
 295     SfxDispatcher* pDispatcher = GetBindings().GetDispatcher();
 296     sal_uInt16 nPos = xColorSet->GetSelectedItemId();
 297     Color  aColor( xColorSet->GetItemColor( nPos ) );
 298     OUString aStr( xColorSet->GetItemText( nPos ) );
 299
 300     if (xColorSet->IsLeftButton())
 301     {
 302         if ( gnLeftSlot == SID_ATTR_FILL_COLOR )
 303         {
 304             if ( nPos == 1 )        // invisible
 305             {
 306                 XFillStyleItem aXFillStyleItem( drawing::FillStyle_NONE );
 307                 pDispatcher->ExecuteList(gnLeftSlot, SfxCallMode::RECORD,
 308                         { &aXFillStyleItem });
 309             }
 310             else
 311             {
 312                 bool bDone = false;
 313
 314                 // If we have a DrawView and we are in TextEdit mode, then
 315                 // not the area color but the text color is assigned
 316                 SfxViewShell* pViewSh = SfxViewShell::Current();
 317                 if ( pViewSh )
 318                 {
 319                     SdrView* pView = pViewSh->GetDrawView();
 320                     if ( pView && pView->IsTextEdit() )
 321                     {
 322                         SvxColorItem aTextColorItem( aColor, SID_ATTR_CHAR_COLOR );
 323                         pDispatcher->ExecuteList(SID_ATTR_CHAR_COLOR,
 324                                 SfxCallMode::RECORD, { &aTextColorItem });
 325                         bDone = true;
 326                     }
 327                 }
 328                 if ( !bDone )
 329                 {
 330                     XFillStyleItem aXFillStyleItem( drawing::FillStyle_SOLID );
 331                     XFillColorItem aXFillColorItem( aStr, aColor );
 332                     pDispatcher->ExecuteList(gnLeftSlot, SfxCallMode::RECORD,
 333                             { &aXFillColorItem, &aXFillStyleItem });
 334                 }
 335             }
 336         }
 337         else if ( nPos != 1 )       // invisible
 338         {
 339             SvxColorItem aLeftColorItem( aColor, gnLeftSlot );
 340             pDispatcher->ExecuteList(gnLeftSlot, SfxCallMode::RECORD,
 341                     { &aLeftColorItem });
 342         }
 343     }
 344     else
 345     {
 346         if ( gnRightSlot == SID_ATTR_LINE_COLOR )
 347         {
 348             if( nPos == 1 )     // invisible
 349             {
 350                 XLineStyleItem aXLineStyleItem( drawing::LineStyle_NONE );
 351                 pDispatcher->ExecuteList(gnRightSlot, SfxCallMode::RECORD,
 352                         { &aXLineStyleItem });
 353             }
 354             else
 355             {
 356                 // If the LineStyle is invisible, it is set to SOLID
 357                 SfxViewShell* pViewSh = SfxViewShell::Current();
 358                 if ( pViewSh )
 359                 {
 360                     SdrView* pView = pViewSh->GetDrawView();
 361                     if ( pView )
 362                     {
 363                         SfxItemSet aAttrSet(pView->GetModel().GetItemPool());
 364                         pView->GetAttributes( aAttrSet );
 365                         if ( aAttrSet.GetItemState( XATTR_LINESTYLE ) != SfxItemState::DONTCARE )
 366                         {
 367                             drawing::LineStyle eXLS =
 368                                 aAttrSet.Get( XATTR_LINESTYLE ).GetValue();
 369                             if ( eXLS == drawing::LineStyle_NONE )
 370                             {
 371                                 XLineStyleItem aXLineStyleItem( drawing::LineStyle_SOLID );
 372                                 pDispatcher->ExecuteList(gnRightSlot,
 373                                     SfxCallMode::RECORD, { &aXLineStyleItem });
 374                             }
 375                         }
 376                     }
 377                 }
 378
 379                 XLineColorItem aXLineColorItem( aStr, aColor );
 380                 pDispatcher->ExecuteList(gnRightSlot, SfxCallMode::RECORD,
 381                         { &aXLineColorItem });
 382             }
 383         }
 384         else if ( nPos != 1 )       // invisible
 385         {
 386             SvxColorItem aRightColorItem( aColor, gnRightSlot );
 387             pDispatcher->ExecuteList(gnRightSlot, SfxCallMode::RECORD,
 388                     { &aRightColorItem });
 389         }
 390     }
 391 }
 392
 393 void SvxColorDockingWindow::GetFocus()
 394 {
 395     SfxDockingWindow::GetFocus();
 396     if (xColorSet)
 397     {
 398         // Grab the focus to the color value set so that it can be controlled
 399         // with the keyboard.
 400         xColorSet->GrabFocus();
 401     }
 402 }
 403
 404 bool SvxColorDockingWindow::EventNotify( NotifyEvent& rNEvt )
 405 {
 406     bool bRet = false;
 407     if( rNEvt.GetType() == NotifyEventType::KEYINPUT )
 408     {
 409         KeyEvent aKeyEvt = *rNEvt.GetKeyEvent();
 410         sal_uInt16   nKeyCode = aKeyEvt.GetKeyCode().GetCode();
 411         switch( nKeyCode )
 412         {
 413             case KEY_ESCAPE:
 414                 GrabFocusToDocument();
 415                 bRet = true;
 416                 break;
 417         }
 418     }
 419
 420     return bRet || SfxDockingWindow::EventNotify(rNEvt);
 421 }
 422
 423 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */