svtools/source/hatchwindow/hatchwindow.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 <com/sun/star/embed/XHatchWindowController.hpp>
  21
  22 #include "hatchwindow.hxx"
  23 #include "ipwin.hxx"
  24
  25 #include <toolkit/helper/convert.hxx>
  26 #include <cppuhelper/queryinterface.hxx>
  27 #include <osl/mutex.hxx>
  28 #include <vcl/svapp.hxx>
  29
  30 using namespace ::com::sun::star;
  31
  32 VCLXHatchWindow::VCLXHatchWindow()
  33 : VCLXWindow()
  34 , pHatchWindow(0)
  35 {
  36 }
  37
  38 VCLXHatchWindow::~VCLXHatchWindow()
  39 {
  40 }
  41
  42 void VCLXHatchWindow::initializeWindow( const uno::Reference< awt::XWindowPeer >& xParent,
  43                 const awt::Rectangle& aBounds,
  44                 const awt::Size& aSize )
  45 {
  46     SolarMutexGuard aGuard;
  47
  48     vcl::Window* pParent = NULL;
  49     VCLXWindow* pParentComponent = VCLXWindow::GetImplementation( xParent );
  50
  51     if ( pParentComponent )
  52         pParent = pParentComponent->GetWindow();
  53
  54     OSL_ENSURE( pParent, "No parent window is provided!\n" );
  55     if ( !pParent )
  56         throw lang::IllegalArgumentException(); // TODO
  57
  58     pHatchWindow = VclPtr<SvResizeWindow>::Create( pParent, this );
  59     pHatchWindow->setPosSizePixel( aBounds.X, aBounds.Y, aBounds.Width, aBounds.Height );
  60     aHatchBorderSize = aSize;
  61     pHatchWindow->SetHatchBorderPixel( Size( aSize.Width, aSize.Height ) );
  62
  63     SetWindow( pHatchWindow );
  64     pHatchWindow->SetComponentInterface( this );
  65
  66     //pHatchWindow->Show();
  67 }
  68
  69 void VCLXHatchWindow::QueryObjAreaPixel( Rectangle & aRect )
  70 {
  71     if ( m_xController.is() )
  72     {
  73         awt::Rectangle aUnoRequestRect = AWTRectangle( aRect );
  74
  75         try {
  76             awt::Rectangle aUnoResultRect = m_xController->calcAdjustedRectangle( aUnoRequestRect );
  77             aRect = VCLRectangle( aUnoResultRect );
  78         }
  79         catch( uno::Exception& )
  80         {
  81             OSL_FAIL( "Can't adjust rectangle size!\n" );
  82         }
  83     }
  84 }
  85
  86 void VCLXHatchWindow::RequestObjAreaPixel( const Rectangle & aRect )
  87 {
  88     if ( m_xController.is() )
  89     {
  90         awt::Rectangle aUnoRequestRect = AWTRectangle( aRect );
  91
  92         try {
  93             m_xController->requestPositioning( aUnoRequestRect );
  94         }
  95         catch( uno::Exception& )
  96         {
  97             OSL_FAIL( "Can't request resizing!\n" );
  98         }
  99     }
 100 }
 101
 102 void VCLXHatchWindow::InplaceDeactivate()
 103 {
 104     if ( m_xController.is() )
 105     {
 106         // TODO: communicate with controller
 107     }
 108 }
 109
 110
 111 uno::Any SAL_CALL VCLXHatchWindow::queryInterface( const uno::Type & rType )
 112     throw( uno::RuntimeException, std::exception )
 113 {
 114     // Attention:
 115     //    Don't use mutex or guard in this method!!! Is a method of XInterface.
 116
 117     uno::Any aReturn( ::cppu::queryInterface( rType,
 118                                            static_cast< embed::XHatchWindow* >( this ) ) );
 119
 120     if ( aReturn.hasValue() )
 121     {
 122         return aReturn ;
 123     }
 124
 125     return VCLXWindow::queryInterface( rType ) ;
 126 }
 127
 128 void SAL_CALL VCLXHatchWindow::acquire()
 129     throw()
 130 {
 131     VCLXWindow::acquire();
 132 }
 133
 134 void SAL_CALL VCLXHatchWindow::release()
 135     throw()
 136 {
 137     VCLXWindow::release();
 138 }
 139
 140 uno::Sequence< uno::Type > SAL_CALL VCLXHatchWindow::getTypes()
 141     throw( uno::RuntimeException, std::exception )
 142 {
 143     static ::cppu::OTypeCollection* pTypeCollection = NULL ;
 144
 145     if ( pTypeCollection == NULL )
 146     {
 147         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ) ;
 148
 149         if ( pTypeCollection == NULL )
 150         {
 151             static ::cppu::OTypeCollection aTypeCollection(
 152                     cppu::UnoType<embed::XHatchWindow>::get(),
 153                     VCLXHatchWindow::getTypes() );
 154
 155             pTypeCollection = &aTypeCollection ;
 156         }
 157     }
 158
 159     return pTypeCollection->getTypes() ;
 160 }
 161
 162 uno::Sequence< sal_Int8 > SAL_CALL VCLXHatchWindow::getImplementationId()
 163     throw( uno::RuntimeException, std::exception )
 164 {
 165     return css::uno::Sequence<sal_Int8>();
 166 }
 167
 168 ::com::sun::star::awt::Size SAL_CALL VCLXHatchWindow::getHatchBorderSize() throw (::com::sun::star::uno::RuntimeException, std::exception)
 169 {
 170     return aHatchBorderSize;
 171 }
 172
 173 void SAL_CALL VCLXHatchWindow::setHatchBorderSize( const ::com::sun::star::awt::Size& _hatchbordersize ) throw (::com::sun::star::uno::RuntimeException, std::exception)
 174 {
 175     if ( pHatchWindow )
 176     {
 177         aHatchBorderSize = _hatchbordersize;
 178         pHatchWindow->SetHatchBorderPixel( Size( aHatchBorderSize.Width, aHatchBorderSize.Height ) );
 179     }
 180 }
 181
 182 void SAL_CALL VCLXHatchWindow::setController( const uno::Reference< embed::XHatchWindowController >& xController )
 183     throw (uno::RuntimeException, std::exception)
 184 {
 185     m_xController = xController;
 186 }
 187
 188 void SAL_CALL VCLXHatchWindow::dispose()
 189     throw (uno::RuntimeException, std::exception)
 190 {
 191     pHatchWindow.clear();
 192     VCLXWindow::dispose();
 193 }
 194
 195 void SAL_CALL VCLXHatchWindow::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 196     throw (uno::RuntimeException, std::exception)
 197 {
 198     VCLXWindow::addEventListener( xListener );
 199 }
 200
 201 void SAL_CALL VCLXHatchWindow::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 202     throw (uno::RuntimeException, std::exception)
 203 {
 204     VCLXWindow::removeEventListener( xListener );
 205 }
 206
 207 void VCLXHatchWindow::Activated()
 208 {
 209     if ( m_xController.is() )
 210         m_xController->activated();
 211 }
 212
 213 void VCLXHatchWindow::Deactivated()
 214 {
 215     if ( m_xController.is() )
 216         m_xController->deactivated();
 217 }
 218
 219 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */