toolkit/source/awt/vclxtopwindow.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 <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  23 #include <com/sun/star/lang/SystemDependent.hpp>
  24 #include <com/sun/star/awt/SystemDependentXWindow.hpp>
  25
  26 #if defined ( MACOSX )
  27 #include <premac.h>
  28 #include <Cocoa/Cocoa.h>
  29 #include <postmac.h>
  30 #endif
  31
  32 #include <vcl/syschild.hxx>
  33 #include <vcl/sysdata.hxx>
  34 #include <cppuhelper/typeprovider.hxx>
  35 #include <comphelper/sequence.hxx>
  36
  37 #include <toolkit/awt/vclxtopwindow.hxx>
  38 #include <toolkit/awt/vclxmenu.hxx>
  39 #include <toolkit/helper/macros.hxx>
  40
  41 #include <vcl/wrkwin.hxx>
  42 #include <vcl/syswin.hxx>
  43 #include <vcl/menu.hxx>
  44 #include <vcl/svapp.hxx>
  45
  46 using ::com::sun::star::uno::RuntimeException;
  47 using ::com::sun::star::uno::Sequence;
  48 using ::com::sun::star::uno::Type;
  49 using ::com::sun::star::uno::Any;
  50 using ::com::sun::star::lang::IndexOutOfBoundsException;
  51
  52 VCLXTopWindow_Base::VCLXTopWindow_Base()
  53 {
  54 }
  55
  56 VCLXTopWindow_Base::~VCLXTopWindow_Base()
  57 {
  58 }
  59
  60 Any VCLXTopWindow_Base::queryInterface( const Type & rType )
  61 {
  62     css::uno::Any aRet( VCLXTopWindow_XBase::queryInterface( rType ) );
  63
  64     if (!aRet.hasValue())
  65         aRet = VCLXTopWindow_SBase::queryInterface( rType );
  66
  67     return aRet;
  68 }
  69
  70 Sequence< Type > VCLXTopWindow_Base::getTypes()
  71 {
  72     Sequence< Type > aTypes( VCLXTopWindow_XBase::getTypes() );
  73     aTypes = ::comphelper::concatSequences( aTypes, VCLXTopWindow_SBase::getTypes() );
  74     return aTypes;
  75 }
  76
  77 css::uno::Any VCLXTopWindow_Base::getWindowHandle( const css::uno::Sequence< sal_Int8 >& /*ProcessId*/, sal_Int16 SystemType )
  78 {
  79     SolarMutexGuard aGuard;
  80
  81     // TODO, check the process id
  82     css::uno::Any aRet;
  83     vcl::Window* pWindow = GetWindowImpl();
  84     if ( pWindow )
  85     {
  86         const SystemEnvData* pSysData = static_cast<SystemWindow *>(pWindow)->GetSystemData();
  87         if( pSysData )
  88         {
  89 #if defined (_WIN32)
  90             if( SystemType == css::lang::SystemDependent::SYSTEM_WIN32 )
  91             {
  92                  aRet <<= reinterpret_cast<sal_IntPtr>(pSysData->hWnd);
  93             }
  94 #elif defined(MACOSX)
  95             if( SystemType == css::lang::SystemDependent::SYSTEM_MAC )
  96             {
  97                  aRet <<= reinterpret_cast<sal_IntPtr>(pSysData->mpNSView);
  98             }
  99 #elif defined(ANDROID)
 100             // Nothing
 101             (void) SystemType;
 102 #elif defined(IOS)
 103             // Nothing
 104             (void) SystemType;
 105 #elif defined(UNX)
 106             if( SystemType == css::lang::SystemDependent::SYSTEM_XWINDOW )
 107             {
 108                 css::awt::SystemDependentXWindow aSD;
 109                 aSD.DisplayPointer = sal::static_int_cast< sal_Int64 >(reinterpret_cast< sal_IntPtr >(pSysData->pDisplay));
 110                 aSD.WindowHandle = pSysData->aWindow;
 111                 aRet <<= aSD;
 112             }
 113 #endif
 114         }
 115     }
 116     return aRet;
 117 }
 118
 119 void VCLXTopWindow_Base::addTopWindowListener( const css::uno::Reference< css::awt::XTopWindowListener >& rxListener )
 120 {
 121     SolarMutexGuard aGuard;
 122
 123     GetTopWindowListenersImpl().addInterface( rxListener );
 124 }
 125
 126 void VCLXTopWindow_Base::removeTopWindowListener( const css::uno::Reference< css::awt::XTopWindowListener >& rxListener )
 127 {
 128     SolarMutexGuard aGuard;
 129
 130     GetTopWindowListenersImpl().removeInterface( rxListener );
 131 }
 132
 133 void VCLXTopWindow_Base::toFront(  )
 134 {
 135     SolarMutexGuard aGuard;
 136
 137     vcl::Window* pWindow = GetWindowImpl();
 138     if ( pWindow )
 139         static_cast<WorkWindow*>(pWindow)->ToTop( ToTopFlags::RestoreWhenMin );
 140 }
 141
 142 void VCLXTopWindow_Base::toBack(  )
 143 {
 144 }
 145
 146 void VCLXTopWindow_Base::setMenuBar( const css::uno::Reference< css::awt::XMenuBar >& rxMenu )
 147 {
 148     SolarMutexGuard aGuard;
 149
 150     vcl::Window* pWindow = GetWindowImpl();
 151     if ( pWindow )
 152     {
 153         SystemWindow* pSystemWindow = static_cast<SystemWindow*>( pWindow );
 154         pSystemWindow->SetMenuBar( nullptr );
 155         if ( rxMenu.is() )
 156         {
 157             VCLXMenu* pMenu = VCLXMenu::GetImplementation( rxMenu );
 158             if ( pMenu && !pMenu->IsPopupMenu() )
 159                 pSystemWindow->SetMenuBar( static_cast<MenuBar*>( pMenu->GetMenu() ));
 160         }
 161     }
 162 }
 163
 164
 165 sal_Bool SAL_CALL VCLXTopWindow_Base::getIsMaximized()
 166 {
 167     SolarMutexGuard aGuard;
 168
 169     const WorkWindow* pWindow = dynamic_cast< const WorkWindow* >( GetWindowImpl() );
 170     if ( !pWindow )
 171         return false;
 172
 173     return pWindow->IsMaximized();
 174 }
 175
 176
 177 void SAL_CALL VCLXTopWindow_Base::setIsMaximized( sal_Bool _ismaximized )
 178 {
 179     SolarMutexGuard aGuard;
 180
 181     WorkWindow* pWindow = dynamic_cast< WorkWindow* >( GetWindowImpl() );
 182     if ( !pWindow )
 183         return;
 184
 185     pWindow->Maximize( _ismaximized );
 186 }
 187
 188
 189 sal_Bool SAL_CALL VCLXTopWindow_Base::getIsMinimized()
 190 {
 191     SolarMutexGuard aGuard;
 192
 193     const WorkWindow* pWindow = dynamic_cast< const WorkWindow* >( GetWindowImpl() );
 194     if ( !pWindow )
 195         return false;
 196
 197     return pWindow->IsMinimized();
 198 }
 199
 200
 201 void SAL_CALL VCLXTopWindow_Base::setIsMinimized( sal_Bool _isMinimized )
 202 {
 203     SolarMutexGuard aGuard;
 204
 205     WorkWindow* pWindow = dynamic_cast< WorkWindow* >( GetWindowImpl() );
 206     if ( !pWindow )
 207         return;
 208
 209     _isMinimized ? pWindow->Minimize() : pWindow->Restore();
 210 }
 211
 212
 213 ::sal_Int32 SAL_CALL VCLXTopWindow_Base::getDisplay()
 214 {
 215     SolarMutexGuard aGuard;
 216
 217     const SystemWindow* pWindow = dynamic_cast< const SystemWindow* >( GetWindowImpl() );
 218     if ( !pWindow )
 219         return 0;
 220
 221     return pWindow->GetScreenNumber();
 222 }
 223
 224
 225 void SAL_CALL VCLXTopWindow_Base::setDisplay( ::sal_Int32 _display )
 226 {
 227     SolarMutexGuard aGuard;
 228
 229     if ( ( _display < 0 ) || ( _display >= static_cast<sal_Int32>(Application::GetScreenCount()) ) )
 230         throw IndexOutOfBoundsException();
 231
 232     SystemWindow* pWindow = dynamic_cast< SystemWindow* >( GetWindowImpl() );
 233     if ( !pWindow )
 234         return;
 235
 236     pWindow->SetScreenNumber( _display );
 237 }
 238
 239
 240 //  class VCLXTopWindow
 241
 242
 243 void VCLXTopWindow::ImplGetPropertyIds( std::vector< sal_uInt16 > &rIds )
 244 {
 245     VCLXContainer::ImplGetPropertyIds( rIds );
 246 }
 247
 248 VCLXTopWindow::VCLXTopWindow()
 249 {
 250 }
 251
 252 VCLXTopWindow::~VCLXTopWindow()
 253 {
 254 }
 255
 256 vcl::Window* VCLXTopWindow::GetWindowImpl()
 257 {
 258     return VCLXContainer::GetWindow();
 259 }
 260
 261 ::comphelper::OInterfaceContainerHelper2& VCLXTopWindow::GetTopWindowListenersImpl()
 262 {
 263     return GetTopWindowListeners();
 264 }
 265
 266 // css::uno::XInterface
 267 css::uno::Any VCLXTopWindow::queryInterface( const css::uno::Type & rType )
 268 {
 269     css::uno::Any aRet( VCLXTopWindow_Base::queryInterface( rType ) );
 270
 271     if ( !aRet.hasValue() )
 272         aRet = VCLXContainer::queryInterface( rType );
 273
 274     return aRet;
 275 }
 276
 277 css::uno::Sequence< sal_Int8 > VCLXTopWindow::getImplementationId()
 278 {
 279     return css::uno::Sequence<sal_Int8>();
 280 }
 281
 282 css::uno::Sequence< css::uno::Type > VCLXTopWindow::getTypes()
 283 {
 284     return ::comphelper::concatSequences( VCLXTopWindow_Base::getTypes(), VCLXContainer::getTypes() );
 285 }
 286
 287 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */