framework/source/layoutmanager/helpers.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 "helpers.hxx"
  21 #include <services.h>
  22
  23 #include <com/sun/star/ui/DockingArea.hpp>
  24 #include <com/sun/star/awt/Toolkit.hpp>
  25 #include <com/sun/star/awt/XTopWindow.hpp>
  26 #include <com/sun/star/frame/DispatchHelper.hpp>
  27 #include <com/sun/star/awt/XDockableWindow.hpp>
  28 #include <com/sun/star/awt/XDockableWindowListener.hpp>
  29 #include <com/sun/star/awt/XWindowListener.hpp>
  30 #include <com/sun/star/ui/XUIElement.hpp>
  31
  32 #include <unotools/mediadescriptor.hxx>
  33 #include <vcl/svapp.hxx>
  34 #include <toolkit/helper/vclunohelper.hxx>
  35
  36 using namespace com::sun::star;
  37
  38 namespace framework
  39 {
  40
  41 bool hasEmptySize( const css::awt::Size& rSize )
  42 {
  43     return ( rSize.Width == 0 ) && ( rSize.Height == 0 );
  44 }
  45
  46 bool hasDefaultPosValue( const css::awt::Point& rPos )
  47 {
  48     return (( rPos.X == SAL_MAX_INT32 ) || ( rPos.Y == SAL_MAX_INT32 ));
  49 }
  50
  51 bool isDefaultPos( const css::awt::Point& rPos )
  52 {
  53     return (( rPos.X == SAL_MAX_INT32 ) && ( rPos.Y == SAL_MAX_INT32 ));
  54 }
  55
  56 bool isReverseOrderDockingArea( const sal_Int32 nDockArea )
  57 {
  58     ui::DockingArea eDockArea = static_cast< ui::DockingArea >( nDockArea );
  59     return (( eDockArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) ||
  60             ( eDockArea == ui::DockingArea_DOCKINGAREA_RIGHT ));
  61 }
  62
  63 bool isToolboxHorizontalAligned( ToolBox const * pToolBox )
  64 {
  65     if ( pToolBox )
  66         return (( pToolBox->GetAlign() == WindowAlign::Top ) || ( pToolBox->GetAlign() == WindowAlign::Bottom ));
  67     return false;
  68 }
  69
  70 bool isHorizontalDockingArea( const ui::DockingArea& nDockingArea )
  71 {
  72     return (( nDockingArea == ui::DockingArea_DOCKINGAREA_TOP ) ||
  73             ( nDockingArea == ui::DockingArea_DOCKINGAREA_BOTTOM ));
  74 }
  75
  76 bool isHorizontalDockingArea( const sal_Int32 nDockArea )
  77 {
  78   return isHorizontalDockingArea(static_cast< ui::DockingArea >( nDockArea ));
  79 }
  80
  81 OUString retrieveToolbarNameFromHelpURL( vcl::Window* pWindow )
  82 {
  83     OUString aToolbarName;
  84
  85     if ( pWindow->GetType() == WindowType::TOOLBOX )
  86     {
  87         ToolBox* pToolBox = dynamic_cast<ToolBox *>( pWindow );
  88         if ( pToolBox )
  89         {
  90             aToolbarName = OStringToOUString( pToolBox->GetHelpId(), RTL_TEXTENCODING_UTF8 );
  91             sal_Int32 i = aToolbarName.lastIndexOf( ':' );
  92             if ( !aToolbarName.isEmpty() && ( i > 0 ) && (( i + 1 ) < aToolbarName.getLength() ))
  93                 aToolbarName = aToolbarName.copy( i+1 ); // Remove ".HelpId:" protocol from toolbar name
  94             else
  95               aToolbarName.clear();
  96         }
  97     }
  98     return aToolbarName;
  99 }
 100
 101 ToolBox* getToolboxPtr( vcl::Window* pWindow )
 102 {
 103     ToolBox* pToolbox(nullptr);
 104     if ( pWindow->GetType() == WindowType::TOOLBOX )
 105         pToolbox = dynamic_cast<ToolBox*>( pWindow );
 106     return pToolbox;
 107 }
 108
 109 vcl::Window* getWindowFromXUIElement( const uno::Reference< ui::XUIElement >& xUIElement )
 110 {
 111     SolarMutexGuard aGuard;
 112     uno::Reference< awt::XWindow > xWindow;
 113     if ( xUIElement.is() )
 114         xWindow.set( xUIElement->getRealInterface(), uno::UNO_QUERY );
 115     return VCLUnoHelper::GetWindow( xWindow );
 116 }
 117
 118 SystemWindow* getTopSystemWindow( const uno::Reference< awt::XWindow >& xWindow )
 119 {
 120     VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
 121     while ( pWindow && !pWindow->IsSystemWindow() )
 122         pWindow = pWindow->GetParent();
 123
 124     if ( pWindow )
 125         return static_cast<SystemWindow *>(pWindow.get());
 126     else
 127         return nullptr;
 128 }
 129
 130 void setZeroRectangle( ::tools::Rectangle& rRect )
 131 {
 132     rRect.setX(0);
 133     rRect.setY(0);
 134     rRect.setWidth(0);
 135     rRect.setHeight(0);
 136 }
 137
 138 // ATTENTION!
 139 // This value is directly copied from the sfx2 project.
 140 // You have to change BOTH values, see sfx2/inc/sfx2/sfxsids.hrc (SID_DOCKWIN_START)
 141 static const sal_Int32 DOCKWIN_ID_BASE = 9800;
 142
 143 bool lcl_checkUIElement(const uno::Reference< ui::XUIElement >& xUIElement, awt::Rectangle& _rPosSize, uno::Reference< awt::XWindow >& _xWindow)
 144 {
 145     bool bRet = xUIElement.is();
 146     if ( bRet )
 147     {
 148         SolarMutexGuard aGuard;
 149         _xWindow.set( xUIElement->getRealInterface(), uno::UNO_QUERY );
 150         _rPosSize = _xWindow->getPosSize();
 151
 152         VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( _xWindow );
 153         if ( pWindow->GetType() == WindowType::TOOLBOX )
 154         {
 155             ::Size aSize = static_cast<ToolBox*>(pWindow.get())->CalcWindowSizePixel( 1 );
 156             _rPosSize.Width = aSize.Width();
 157             _rPosSize.Height = aSize.Height();
 158         }
 159     } // if ( xUIElement.is() )
 160     return bRet;
 161 }
 162
 163 uno::Reference< awt::XWindowPeer > createToolkitWindow( const uno::Reference< uno::XComponentContext >& rxContext, const uno::Reference< awt::XWindowPeer >& rParent, const char* pService )
 164 {
 165     uno::Reference< awt::XToolkit2 > xToolkit = awt::Toolkit::create( rxContext );
 166
 167     // describe window properties.
 168     css::awt::WindowDescriptor aDescriptor;
 169     aDescriptor.Type                =   awt::WindowClass_SIMPLE;
 170     aDescriptor.WindowServiceName   =   OUString::createFromAscii( pService );
 171     aDescriptor.ParentIndex         =   -1;
 172     aDescriptor.Parent = rParent;
 173     aDescriptor.Bounds              =   awt::Rectangle(0,0,0,0);
 174     aDescriptor.WindowAttributes    =   0;
 175
 176     // create an awt window
 177     uno::Reference< awt::XWindowPeer > xPeer = xToolkit->createWindow( aDescriptor );
 178
 179     return xPeer;
 180 }
 181
 182 // convert alignment constant to vcl's WindowAlign type
 183 WindowAlign ImplConvertAlignment( ui::DockingArea aAlignment )
 184 {
 185     if ( aAlignment == ui::DockingArea_DOCKINGAREA_LEFT )
 186         return WindowAlign::Left;
 187     else if ( aAlignment == ui::DockingArea_DOCKINGAREA_RIGHT )
 188         return WindowAlign::Right;
 189     else if ( aAlignment == ui::DockingArea_DOCKINGAREA_TOP )
 190         return WindowAlign::Top;
 191     else
 192         return WindowAlign::Bottom;
 193 }
 194
 195 OUString getElementTypeFromResourceURL( const OUString& aResourceURL )
 196 {
 197     OUString aUIResourceURL( UIRESOURCE_URL );
 198     if ( aResourceURL.startsWith( aUIResourceURL ) )
 199     {
 200         sal_Int32 nIndex{ aUIResourceURL.getLength() };
 201         return aResourceURL.getToken( 1, '/', nIndex );
 202     }
 203
 204     return OUString();
 205 }
 206
 207 void parseResourceURL( const OUString& aResourceURL, OUString& aElementType, OUString& aElementName )
 208 {
 209     OUString aUIResourceURL( UIRESOURCE_URL );
 210     if ( aResourceURL.startsWith( aUIResourceURL ) )
 211     {
 212         sal_Int32 nIndex{ aUIResourceURL.getLength() };
 213         aElementType = aResourceURL.getToken( 1, '/', nIndex );
 214         aElementName = aResourceURL.getToken( 0, '/', nIndex );
 215     }
 216 }
 217
 218 css::awt::Rectangle putRectangleValueToAWT( const ::tools::Rectangle& rRect )
 219 {
 220     css::awt::Rectangle aRect;
 221     aRect.X = rRect.Left();
 222     aRect.Y = rRect.Top();
 223     aRect.Width = rRect.Right();
 224     aRect.Height = rRect.Bottom();
 225
 226     return aRect;
 227 }
 228
 229 ::tools::Rectangle putAWTToRectangle( const css::awt::Rectangle& rRect )
 230 {
 231     ::tools::Rectangle aRect;
 232     aRect.SetLeft( rRect.X );
 233     aRect.SetTop( rRect.Y );
 234     aRect.SetRight( rRect.Width );
 235     aRect.SetBottom( rRect.Height );
 236
 237     return aRect;
 238 }
 239
 240 bool equalRectangles( const css::awt::Rectangle& rRect1,
 241                       const css::awt::Rectangle& rRect2 )
 242 {
 243     return (( rRect1.X == rRect2.X ) &&
 244             ( rRect1.Y == rRect2.Y ) &&
 245             ( rRect1.Width == rRect2.Width ) &&
 246             ( rRect1.Height == rRect2.Height ));
 247 }
 248
 249 uno::Reference< frame::XModel > impl_getModelFromFrame( const uno::Reference< frame::XFrame >& rFrame )
 250 {
 251     // Query for the model to get check the context information
 252     uno::Reference< frame::XModel > xModel;
 253     if ( rFrame.is() )
 254     {
 255         uno::Reference< frame::XController > xController = rFrame->getController();
 256         if ( xController.is() )
 257             xModel = xController->getModel();
 258     }
 259
 260     return xModel;
 261 }
 262
 263 bool implts_isPreviewModel( const uno::Reference< frame::XModel >& xModel )
 264 {
 265     if ( xModel.is() )
 266     {
 267         utl::MediaDescriptor aDesc( xModel->getArgs() );
 268         return aDesc.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_PREVIEW(), false);
 269     }
 270     else
 271         return false;
 272 }
 273
 274 bool implts_isFrameOrWindowTop( const uno::Reference< frame::XFrame >& xFrame )
 275 {
 276     if (xFrame->isTop())
 277         return true;
 278
 279     uno::Reference< awt::XTopWindow > xWindowCheck(xFrame->getContainerWindow(), uno::UNO_QUERY); // don't use _THROW here ... it's a check only
 280     if (xWindowCheck.is())
 281     {
 282         // #i76867# top and system window is required.
 283         SolarMutexGuard aGuard;
 284         uno::Reference< awt::XWindow > xWindow( xWindowCheck, uno::UNO_QUERY );
 285         VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xWindow );
 286         return pWindow && pWindow->IsSystemWindow();
 287     }
 288
 289     return false;
 290 }
 291
 292 void impl_setDockingWindowVisibility( const css::uno::Reference< css::uno::XComponentContext>& rxContext, const css::uno::Reference< css::frame::XFrame >& rFrame, const OUString& rDockingWindowName, bool bVisible )
 293 {
 294     sal_Int32 nID    = rDockingWindowName.toInt32();
 295     sal_Int32 nIndex = nID - DOCKWIN_ID_BASE;
 296
 297     css::uno::Reference< css::frame::XDispatchProvider > xProvider(rFrame, css::uno::UNO_QUERY);
 298     if ( nIndex >= 0 && xProvider.is() )
 299     {
 300         OUString aDockWinArgName = "DockingWindow" + OUString::number( nIndex );
 301
 302         css::uno::Sequence< css::beans::PropertyValue > aArgs(1);
 303         aArgs[0].Name  = aDockWinArgName;
 304         aArgs[0].Value <<= bVisible;
 305
 306         css::uno::Reference< css::frame::XDispatchHelper > xDispatcher = css::frame::DispatchHelper::create( rxContext );
 307
 308         OUString aDockWinCommand = ".uno:" + aDockWinArgName;
 309         xDispatcher->executeDispatch(
 310             xProvider,
 311             aDockWinCommand,
 312             "_self",
 313             0,
 314             aArgs);
 315     }
 316 }
 317
 318 void impl_addWindowListeners(
 319     const css::uno::Reference< css::uno::XInterface >& xThis,
 320     const css::uno::Reference< css::ui::XUIElement >& xUIElement )
 321 {
 322     css::uno::Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), css::uno::UNO_QUERY );
 323     css::uno::Reference< css::awt::XDockableWindow > xDockWindow( xUIElement->getRealInterface(), css::uno::UNO_QUERY );
 324     if ( xDockWindow.is() && xWindow.is() )
 325     {
 326         try
 327         {
 328             xDockWindow->addDockableWindowListener(
 329                 css::uno::Reference< css::awt::XDockableWindowListener >(
 330                     xThis, css::uno::UNO_QUERY ));
 331             xWindow->addWindowListener(
 332                 css::uno::Reference< css::awt::XWindowListener >(
 333                     xThis, css::uno::UNO_QUERY ));
 334             xDockWindow->enableDocking( true );
 335         }
 336         catch ( const css::uno::Exception& )
 337         {
 338         }
 339     }
 340 }
 341
 342 } // namespace framework
 343
 344 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */