/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the Collabora Office project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ #include #include #include #include #include #include #include #include #include // namespaces using namespace ::cppu; using namespace ::osl; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::lang; using namespace ::com::sun::star::awt; using namespace ::cpo::uno; namespace unocontrols { constexpr sal_Int32 DEFAULT_X = 0; constexpr sal_Int32 DEFAULT_Y = 0; constexpr sal_Int32 DEFAULT_WIDTH = 100; constexpr sal_Int32 DEFAULT_HEIGHT = 100; constexpr bool DEFAULT_VISIBLE = false; constexpr bool DEFAULT_INDESIGNMODE = false; constexpr bool DEFAULT_ENABLE = true; // construct/destruct BaseControl::BaseControl( const Reference< XComponentContext >& rxContext ) : WeakComponentImplHelper ( m_aMutex ) , m_xComponentContext ( rxContext ) , m_nX ( DEFAULT_X ) , m_nY ( DEFAULT_Y ) , m_nWidth ( DEFAULT_WIDTH ) , m_nHeight ( DEFAULT_HEIGHT ) , m_bVisible ( DEFAULT_VISIBLE ) , m_bInDesignMode ( DEFAULT_INDESIGNMODE ) , m_bEnable ( DEFAULT_ENABLE ) { } BaseControl::~BaseControl() { } // XServiceInfo OUString BaseControl::getImplementationName() { return OUString(); } // XServiceInfo bool BaseControl::supportsService( const OUString& sServiceName ) { return cppu::supportsService(this, sServiceName); } // XServiceInfo Sequence< OUString > BaseControl::getSupportedServiceNames() { return Sequence< OUString >(); } // XComponent void BaseControl::dispose() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); if ( m_xMultiplexer.is() ) { // to all other paint, focus, etc. m_xMultiplexer->disposeAndClear(); m_xMultiplexer.clear(); } // set the service manager to disposed WeakComponentImplHelper::dispose(); // release context and peer m_xContext.clear(); if ( m_xPeer.is() ) { if ( m_xGraphicsPeer.is() ) { removePaintListener( this ); removeWindowListener( this ); m_xGraphicsPeer.clear(); } m_xPeer->dispose(); m_xPeerWindow.clear(); m_xPeer.clear(); } // release view if ( m_xGraphicsView.is() ) { m_xGraphicsView.clear(); } } // XComponent void BaseControl::addEventListener( const Reference< XEventListener >& xListener ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); WeakComponentImplHelper::addEventListener( xListener ); } // XComponent void BaseControl::removeEventListener( const Reference< XEventListener >& xListener ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); WeakComponentImplHelper::removeEventListener( xListener ); } // XControl void BaseControl::createPeer( const Reference< XToolkit >& xToolkit , const Reference< XWindowPeer >& xParentPeer ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); if ( m_xPeer.is() ) return; // use method "BaseControl::getWindowDescriptor()" to change window attributes! WindowDescriptor aDescriptor = impl_getWindowDescriptor( xParentPeer ); if ( m_bVisible ) { aDescriptor.WindowAttributes |= WindowAttribute::SHOW; } // very slow under remote conditions! // create the window on the server Reference< XToolkit > xLocalToolkit = xToolkit; if ( !xLocalToolkit.is() ) { // but first create well known toolkit, if it not exist xLocalToolkit.set( Toolkit::create(m_xComponentContext), UNO_QUERY_THROW ); } m_xPeer = xLocalToolkit->createWindow( aDescriptor ); m_xPeerWindow.set( m_xPeer, UNO_QUERY ); if ( !m_xPeerWindow.is() ) return; if ( m_xMultiplexer.is() ) { m_xMultiplexer->setPeer( m_xPeerWindow ); } // create new reference to xgraphics for painting on a peer // and add a paint listener Reference< XDevice > xDevice( m_xPeerWindow, UNO_QUERY ); if ( xDevice.is() ) { m_xGraphicsPeer = xDevice->createGraphics(); } if ( m_xGraphicsPeer.is() ) { addPaintListener( this ); addWindowListener( this ); } m_xPeerWindow->setPosSize( m_nX, m_nY, m_nWidth, m_nHeight, PosSize::POSSIZE ); m_xPeerWindow->setEnable( m_bEnable ); m_xPeerWindow->setVisible( m_bVisible && !m_bInDesignMode ); } // XControl void BaseControl::setContext( const Reference< XInterface >& xContext ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); m_xContext = xContext; } // XControl void BaseControl::setDesignMode( bool bOn ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); m_bInDesignMode = bOn; } // XControl Reference< XInterface > BaseControl::getContext() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); return m_xContext; } // XControl Reference< XWindowPeer > BaseControl::getPeer() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); return m_xPeer; } // XControl Reference< XView > BaseControl::getView() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); return this; } // XControl bool BaseControl::isDesignMode() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); return m_bInDesignMode; } // XControl bool BaseControl::isTransparent() { return false; } // XWindow void BaseControl::setPosSize( sal_Int32 nX , sal_Int32 nY , sal_Int32 nWidth , sal_Int32 nHeight , sal_Int16 nFlags ) { // - change size and position of window and save the values // Ready for multithreading MutexGuard aGuard( m_aMutex ); bool bChanged = false; if ( nFlags & PosSize::X ) { bChanged |= m_nX != nX; m_nX = nX; } if ( nFlags & PosSize::Y ) { bChanged |= m_nY != nY; m_nY = nY; } if ( nFlags & PosSize::WIDTH ) { bChanged |= m_nWidth != nWidth; m_nWidth = nWidth; } if ( nFlags & PosSize::HEIGHT ) { bChanged |= m_nHeight != nHeight; m_nHeight = nHeight; } if ( bChanged && m_xPeerWindow.is() ) { m_xPeerWindow->setPosSize( m_nX, m_nY, m_nWidth, m_nHeight, nFlags ); } } // XWindow void BaseControl::setVisible( bool bVisible ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); // Set new state of flag m_bVisible = bVisible; if ( m_xPeerWindow.is() ) { // Set it also on peerwindow m_xPeerWindow->setVisible( m_bVisible ); } } // XWindow void BaseControl::setEnable( bool bEnable ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); // Set new state of flag m_bEnable = bEnable; if ( m_xPeerWindow.is() ) { // Set it also on peerwindow m_xPeerWindow->setEnable( m_bEnable ); } } // XWindow void BaseControl::setFocus() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); if ( m_xPeerWindow.is() ) { m_xPeerWindow->setFocus(); } } // XWindow Rectangle BaseControl::getPosSize() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); return Rectangle( m_nX, m_nY , m_nWidth, m_nHeight ); } // XWindow void BaseControl::addWindowListener( const Reference< XWindowListener >& xListener ) { impl_getMultiplexer()->advise(xListener); } // XWindow void BaseControl::addFocusListener( const Reference< XFocusListener >& xListener ) { impl_getMultiplexer()->advise(xListener); } // XWindow void BaseControl::addKeyListener( const Reference< XKeyListener >& xListener ) { impl_getMultiplexer()->advise(xListener); } // XWindow void BaseControl::addMouseListener( const Reference< XMouseListener >& xListener ) { impl_getMultiplexer()->advise(xListener); } // XWindow void BaseControl::addMouseMotionListener( const Reference< XMouseMotionListener >& xListener ) { impl_getMultiplexer()->advise(xListener); } // XWindow void BaseControl::addPaintListener( const Reference< XPaintListener >& xListener ) { impl_getMultiplexer()->advise(xListener); } // XWindow void BaseControl::removeWindowListener( const Reference< XWindowListener >& xListener ) { impl_getMultiplexer()->unadvise(xListener); } // XWindow void BaseControl::removeFocusListener( const Reference< XFocusListener >& xListener ) { impl_getMultiplexer()->unadvise(xListener); } // XWindow void BaseControl::removeKeyListener( const Reference< XKeyListener >& xListener ) { impl_getMultiplexer()->unadvise(xListener); } // XWindow void BaseControl::removeMouseListener( const Reference< XMouseListener >& xListener ) { impl_getMultiplexer()->unadvise(xListener); } // XWindow void BaseControl::removeMouseMotionListener( const Reference< XMouseMotionListener >& xListener ) { impl_getMultiplexer()->unadvise(xListener); } // XWindow void BaseControl::removePaintListener( const Reference< XPaintListener >& xListener ) { impl_getMultiplexer()->unadvise(xListener); } // XView void BaseControl::draw( sal_Int32 nX , sal_Int32 nY ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); // - paint to a view // - use the method "paint()" // - see also "windowPaint()" impl_paint( nX, nY, m_xGraphicsView ); } // XView bool BaseControl::setGraphics( const Reference< XGraphics >& xDevice ) { // - set the graphics for a view // - in this class exist 2 graphics-member ... one for peer[_xGraphicsPeer] and one for view[_xGraphicsView] // - they are used by "windowPaint() and draw()", forwarded to "paint ()" bool bReturn = false; if ( xDevice.is() ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); m_xGraphicsView = xDevice; bReturn = true; } return bReturn; } // XView void BaseControl::setZoom( float /*fZoomX*/ , float /*fZoomY*/ ) { // Not implemented yet } // XView Reference< XGraphics > BaseControl::getGraphics() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); return m_xGraphicsView; } // XView Size BaseControl::getSize() { // Ready for multithreading MutexGuard aGuard( m_aMutex ); return Size( m_nWidth, m_nHeight ); } // XEventListener void BaseControl::disposing( const EventObject& /*aSource*/ ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); // - release ALL references // - it must be !!! if ( m_xGraphicsPeer.is() ) { removePaintListener( this ); removeWindowListener( this ); m_xGraphicsPeer.clear(); } if ( m_xGraphicsView.is() ) { m_xGraphicsView.clear(); } } // XPaintListener void BaseControl::windowPaint( const PaintEvent& /*aEvent*/ ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); // - repaint the peer // - use the method "paint ()" for painting on a peer and a print device !!! // - see also "draw ()" impl_paint( 0, 0, m_xGraphicsPeer ); } // XWindowListener void BaseControl::windowResized( const WindowEvent& aEvent ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); m_nWidth = aEvent.Width; m_nHeight = aEvent.Height; WindowEvent aMappedEvent = aEvent; aMappedEvent.X = 0; aMappedEvent.Y = 0; impl_recalcLayout( aMappedEvent ); } // XWindowListener void BaseControl::windowMoved( const WindowEvent& aEvent ) { // Ready for multithreading MutexGuard aGuard( m_aMutex ); m_nWidth = aEvent.Width; m_nHeight = aEvent.Height; WindowEvent aMappedEvent = aEvent; aMappedEvent.X = 0; aMappedEvent.Y = 0; impl_recalcLayout( aMappedEvent ); } // XWindowListener void BaseControl::windowShown( const EventObject& /*aEvent*/ ) { } // XWindowListener void BaseControl::windowHidden( const EventObject& /*aEvent*/ ) { } // protected method WindowDescriptor BaseControl::impl_getWindowDescriptor( const Reference< XWindowPeer >& xParentPeer ) { // - used from "createPeer()" to set the values of a cpo::awt::WindowDescriptor !!! // - if you will change the descriptor-values, you must override this virtual function // - the caller must release the memory for this dynamical descriptor !!! WindowDescriptor aDescriptor; aDescriptor.Type = WindowClass_SIMPLE; aDescriptor.WindowServiceName = u"window"_ustr; aDescriptor.ParentIndex = -1; aDescriptor.Parent = xParentPeer; aDescriptor.Bounds = getPosSize (); aDescriptor.WindowAttributes = 0; return aDescriptor; } // protected method void BaseControl::impl_paint( sal_Int32 /*nX*/ , sal_Int32 /*nY*/ , const Reference< XGraphics >& /*xGraphics*/ ) { // - one paint method for peer AND view !!! // (see also => "windowPaint()" and "draw()") // - not used in this implementation, but it's not necessary to make it pure virtual !!! } // protected method void BaseControl::impl_recalcLayout( const WindowEvent& /*aEvent*/ ) { // We need as virtual function to support automatically resizing of derived controls! // But we make it not pure virtual because it's not necessary for all derived classes! } // private method OMRCListenerMultiplexerHelper* BaseControl::impl_getMultiplexer() { if ( !m_xMultiplexer.is() ) { m_xMultiplexer = new OMRCListenerMultiplexerHelper( static_cast(this), m_xPeerWindow ); } return m_xMultiplexer.get(); } } // namespace unocontrols /* vim:set shiftwidth=4 softtabstop=4 expandtab: */