diff options
Diffstat (limited to 'UnoControls/source/controls/statusindicator.cxx')
| -rw-r--r-- | UnoControls/source/controls/statusindicator.cxx | 462 |
1 files changed, 462 insertions, 0 deletions
diff --git a/UnoControls/source/controls/statusindicator.cxx b/UnoControls/source/controls/statusindicator.cxx new file mode 100644 index 000000000..033c787d0 --- /dev/null +++ b/UnoControls/source/controls/statusindicator.cxx @@ -0,0 +1,462 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice 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 <statusindicator.hxx> + +#include <com/sun/star/awt/PosSize.hpp> +#include <com/sun/star/awt/XFixedText.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <cppuhelper/queryinterface.hxx> +#include <cppuhelper/typeprovider.hxx> + +#include <progressbar.hxx> + +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 ::com::sun::star::task; + +#define FIXEDTEXT_SERVICENAME "com.sun.star.awt.UnoControlFixedText" +#define FIXEDTEXT_MODELNAME "com.sun.star.awt.UnoControlFixedTextModel" +#define CONTROLNAME_TEXT "Text" // identifier the control in container +#define CONTROLNAME_PROGRESSBAR "ProgressBar" // -||- + +namespace unocontrols { + +// construct/destruct + +StatusIndicator::StatusIndicator( const css::uno::Reference< XComponentContext >& rxContext ) + : BaseContainerControl ( rxContext ) +{ + // It's not allowed to work with member in this method (refcounter !!!) + // But with a HACK (++refcount) its "OK" :-( + osl_atomic_increment(&m_refCount); + + // Create instances for fixedtext and progress ... + m_xText.set( rxContext->getServiceManager()->createInstanceWithContext( FIXEDTEXT_SERVICENAME, rxContext ), UNO_QUERY ); + m_xProgressBar = new ProgressBar(rxContext); + // ... cast controls to css::uno::Reference< XControl > and set model ... + // ( ProgressBar has no model !!! ) + css::uno::Reference< XControl > xTextControl ( m_xText , UNO_QUERY ); + xTextControl->setModel( css::uno::Reference< XControlModel >( rxContext->getServiceManager()->createInstanceWithContext( FIXEDTEXT_MODELNAME, rxContext ), UNO_QUERY ) ); + // ... and add controls to basecontainercontrol! + addControl( CONTROLNAME_TEXT, xTextControl ); + addControl( CONTROLNAME_PROGRESSBAR, m_xProgressBar.get() ); + // FixedText make it automatically visible by himself ... but not the progressbar !!! + // it must be set explicitly + m_xProgressBar->setVisible( true ); + // Reset to defaults !!! + // (progressbar take automatically its own defaults) + m_xText->setText( "" ); + + osl_atomic_decrement(&m_refCount); +} + +StatusIndicator::~StatusIndicator() {} + +// XInterface + +Any SAL_CALL StatusIndicator::queryInterface( const Type& rType ) +{ + // Attention: + // Don't use mutex or guard in this method!!! Is a method of XInterface. + Any aReturn; + css::uno::Reference< XInterface > xDel = BaseContainerControl::impl_getDelegator(); + if ( xDel.is() ) + { + // If a delegator exists, forward question to its queryInterface. + // Delegator will ask its own queryAggregation! + aReturn = xDel->queryInterface( rType ); + } + else + { + // If a delegator is unknown, forward question to own queryAggregation. + aReturn = queryAggregation( rType ); + } + + return aReturn; +} + +// XInterface + +void SAL_CALL StatusIndicator::acquire() throw() +{ + // Attention: + // Don't use mutex or guard in this method!!! Is a method of XInterface. + + // Forward to baseclass + BaseControl::acquire(); +} + +// XInterface + +void SAL_CALL StatusIndicator::release() throw() +{ + // Attention: + // Don't use mutex or guard in this method!!! Is a method of XInterface. + + // Forward to baseclass + BaseControl::release(); +} + +// XTypeProvider + +Sequence< Type > SAL_CALL StatusIndicator::getTypes() +{ + static OTypeCollection ourTypeCollection( + cppu::UnoType<XLayoutConstrains>::get(), + cppu::UnoType<XStatusIndicator>::get(), + BaseContainerControl::getTypes() ); + + return ourTypeCollection.getTypes(); +} + +// XAggregation + +Any SAL_CALL StatusIndicator::queryAggregation( const Type& aType ) +{ + // Ask for my own supported interfaces ... + // Attention: XTypeProvider and XInterface are supported by OComponentHelper! + Any aReturn ( ::cppu::queryInterface( aType , + static_cast< XLayoutConstrains* > ( this ) , + static_cast< XStatusIndicator* > ( this ) + ) + ); + + // If searched interface not supported by this class ... + if ( !aReturn.hasValue() ) + { + // ... ask baseclasses. + aReturn = BaseControl::queryAggregation( aType ); + } + + return aReturn; +} + +// XStatusIndicator + +void SAL_CALL StatusIndicator::start( const OUString& sText, sal_Int32 nRange ) +{ + // Ready for multithreading + MutexGuard aGuard( m_aMutex ); + + // Initialize status controls with given values. + m_xText->setText( sText ); + m_xProgressBar->setRange( 0, nRange ); + // force repaint ... fixedtext has changed ! + impl_recalcLayout ( WindowEvent(static_cast< OWeakObject* >(this),0,0,impl_getWidth(),impl_getHeight(),0,0,0,0) ); +} + +// XStatusIndicator + +void SAL_CALL StatusIndicator::end() +{ + // Ready for multithreading + MutexGuard aGuard( m_aMutex ); + + // Clear values of status controls. + m_xText->setText( OUString() ); + m_xProgressBar->setValue( 0 ); + setVisible( false ); +} + +// XStatusIndicator + +void SAL_CALL StatusIndicator::setText( const OUString& sText ) +{ + // Ready for multithreading + MutexGuard aGuard( m_aMutex ); + + // Take text on right control + m_xText->setText( sText ); +} + +// XStatusIndicator + +void SAL_CALL StatusIndicator::setValue( sal_Int32 nValue ) +{ + // Ready for multithreading + MutexGuard aGuard( m_aMutex ); + + // Take value on right control + m_xProgressBar->setValue( nValue ); +} + +// XStatusIndicator + +void SAL_CALL StatusIndicator::reset() +{ + // Ready for multithreading + MutexGuard aGuard( m_aMutex ); + + // Clear values of status controls. + // (Don't hide the window! User will reset current values ... but he will not finish using of indicator!) + m_xText->setText( OUString() ); + m_xProgressBar->setValue( 0 ); +} + +// XLayoutConstrains + +Size SAL_CALL StatusIndicator::getMinimumSize () +{ + return Size (STATUSINDICATOR_DEFAULT_WIDTH, STATUSINDICATOR_DEFAULT_HEIGHT); +} + +// XLayoutConstrains + +Size SAL_CALL StatusIndicator::getPreferredSize () +{ + // Ready for multithreading + ClearableMutexGuard aGuard ( m_aMutex ); + + // get information about required place of child controls + css::uno::Reference< XLayoutConstrains > xTextLayout ( m_xText, UNO_QUERY ); + Size aTextSize = xTextLayout->getPreferredSize(); + + aGuard.clear (); + + // calc preferred size of status indicator + sal_Int32 nWidth = impl_getWidth(); + sal_Int32 nHeight = (2*STATUSINDICATOR_FREEBORDER)+aTextSize.Height; + + // norm to minimum + if ( nWidth<STATUSINDICATOR_DEFAULT_WIDTH ) + { + nWidth = STATUSINDICATOR_DEFAULT_WIDTH; + } + if ( nHeight<STATUSINDICATOR_DEFAULT_HEIGHT ) + { + nHeight = STATUSINDICATOR_DEFAULT_HEIGHT; + } + + // return to caller + return Size ( nWidth, nHeight ); +} + +// XLayoutConstrains + +Size SAL_CALL StatusIndicator::calcAdjustedSize ( const Size& /*rNewSize*/ ) +{ + return getPreferredSize (); +} + +// XControl + +void SAL_CALL StatusIndicator::createPeer ( + const css::uno::Reference< XToolkit > & rToolkit, + const css::uno::Reference< XWindowPeer > & rParent +) +{ + if( !getPeer().is() ) + { + BaseContainerControl::createPeer( rToolkit, rParent ); + + // If user forget to call "setPosSize()", we have still a correct size. + // And a "MinimumSize" IS A "MinimumSize"! + // We change not the position of control at this point. + Size aDefaultSize = getMinimumSize (); + setPosSize ( 0, 0, aDefaultSize.Width, aDefaultSize.Height, PosSize::SIZE ); + } +} + +// XControl + +sal_Bool SAL_CALL StatusIndicator::setModel ( const css::uno::Reference< XControlModel > & /*rModel*/ ) +{ + // We have no model. + return false; +} + +// XControl + +css::uno::Reference< XControlModel > SAL_CALL StatusIndicator::getModel () +{ + // We have no model. + // return (XControlModel*)this; + return css::uno::Reference< XControlModel > (); +} + +// XComponent + +void SAL_CALL StatusIndicator::dispose () +{ + // Ready for multithreading + MutexGuard aGuard ( m_aMutex ); + + // "removeControl()" control the state of a reference + css::uno::Reference< XControl > xTextControl ( m_xText , UNO_QUERY ); + + removeControl( xTextControl ); + removeControl( m_xProgressBar.get() ); + + // don't use "...->clear ()" or "... = XFixedText ()" + // when other hold a reference at this object !!! + xTextControl->dispose(); + m_xProgressBar->dispose(); + BaseContainerControl::dispose(); +} + +// XWindow + +void SAL_CALL StatusIndicator::setPosSize ( + sal_Int32 nX, + sal_Int32 nY, + sal_Int32 nWidth, + sal_Int32 nHeight, + sal_Int16 nFlags +) +{ + Rectangle aBasePosSize = getPosSize (); + BaseContainerControl::setPosSize (nX, nY, nWidth, nHeight, nFlags); + + // if position or size changed + if ( + ( nWidth != aBasePosSize.Width ) || + ( nHeight != aBasePosSize.Height) + ) + { + // calc new layout for controls + impl_recalcLayout ( WindowEvent(static_cast< OWeakObject* >(this),0,0,nWidth,nHeight,0,0,0,0) ); + // clear background (!) + // [Children were repainted in "recalcLayout" by setPosSize() automatically!] + getPeer()->invalidate(2); + // and repaint the control + impl_paint ( 0, 0, impl_getGraphicsPeer() ); + } +} + +// impl but public method to register service + +Sequence< OUString > StatusIndicator::impl_getStaticSupportedServiceNames() +{ + return css::uno::Sequence<OUString>(); +} + +// impl but public method to register service + +OUString StatusIndicator::impl_getStaticImplementationName() +{ + return "stardiv.UnoControls.StatusIndicator"; +} + +// protected method + +WindowDescriptor StatusIndicator::impl_getWindowDescriptor( const css::uno::Reference< XWindowPeer >& xParentPeer ) +{ + WindowDescriptor aDescriptor; + + aDescriptor.Type = WindowClass_SIMPLE; + aDescriptor.WindowServiceName = "floatingwindow"; + aDescriptor.ParentIndex = -1; + aDescriptor.Parent = xParentPeer; + aDescriptor.Bounds = getPosSize (); + + return aDescriptor; +} + +// protected method + +void StatusIndicator::impl_paint ( sal_Int32 nX, sal_Int32 nY, const css::uno::Reference< XGraphics > & rGraphics ) +{ + // This paint method is not buffered! + // Every request paint the completely control. (But only, if peer exist) + if ( rGraphics.is () ) + { + MutexGuard aGuard (m_aMutex); + + // background = gray + css::uno::Reference< XWindowPeer > xPeer( impl_getPeerWindow(), UNO_QUERY ); + if( xPeer.is() ) + xPeer->setBackground( STATUSINDICATOR_BACKGROUNDCOLOR ); + + // FixedText background = gray + css::uno::Reference< XControl > xTextControl( m_xText, UNO_QUERY ); + xPeer = xTextControl->getPeer(); + if( xPeer.is() ) + xPeer->setBackground( STATUSINDICATOR_BACKGROUNDCOLOR ); + + // Progress background = gray + xPeer = m_xProgressBar->getPeer(); + if( xPeer.is() ) + xPeer->setBackground( STATUSINDICATOR_BACKGROUNDCOLOR ); + + // paint shadow border + rGraphics->setLineColor ( STATUSINDICATOR_LINECOLOR_BRIGHT ); + rGraphics->drawLine ( nX, nY, impl_getWidth(), nY ); + rGraphics->drawLine ( nX, nY, nX , impl_getHeight() ); + + rGraphics->setLineColor ( STATUSINDICATOR_LINECOLOR_SHADOW ); + rGraphics->drawLine ( impl_getWidth()-1, impl_getHeight()-1, impl_getWidth()-1, nY ); + rGraphics->drawLine ( impl_getWidth()-1, impl_getHeight()-1, nX , impl_getHeight()-1 ); + } +} + +// protected method + +void StatusIndicator::impl_recalcLayout ( const WindowEvent& aEvent ) +{ + sal_Int32 nX_ProgressBar; + sal_Int32 nY_ProgressBar; + sal_Int32 nWidth_ProgressBar; + sal_Int32 nHeight_ProgressBar; + sal_Int32 nX_Text; + sal_Int32 nY_Text; + sal_Int32 nWidth_Text; + sal_Int32 nHeight_Text; + + // Ready for multithreading + MutexGuard aGuard ( m_aMutex ); + + // get information about required place of child controls + Size aWindowSize ( aEvent.Width, aEvent.Height ); + css::uno::Reference< XLayoutConstrains > xTextLayout ( m_xText, UNO_QUERY ); + Size aTextSize = xTextLayout->getPreferredSize(); + + if( aWindowSize.Width < STATUSINDICATOR_DEFAULT_WIDTH ) + { + aWindowSize.Width = STATUSINDICATOR_DEFAULT_WIDTH; + } + if( aWindowSize.Height < STATUSINDICATOR_DEFAULT_HEIGHT ) + { + aWindowSize.Height = STATUSINDICATOR_DEFAULT_HEIGHT; + } + + // calc position and size of child controls + nX_Text = STATUSINDICATOR_FREEBORDER; + nY_Text = STATUSINDICATOR_FREEBORDER; + nWidth_Text = aTextSize.Width; + nHeight_Text = aTextSize.Height; + + nX_ProgressBar = nX_Text+nWidth_Text+STATUSINDICATOR_FREEBORDER; + nY_ProgressBar = nY_Text; + nWidth_ProgressBar = aWindowSize.Width-nWidth_Text-(3*STATUSINDICATOR_FREEBORDER); + nHeight_ProgressBar = nHeight_Text; + + // Set new position and size on all controls + css::uno::Reference< XWindow > xTextWindow ( m_xText , UNO_QUERY ); + + xTextWindow->setPosSize ( nX_Text , nY_Text , nWidth_Text , nHeight_Text , 15 ); + m_xProgressBar->setPosSize( nX_ProgressBar, nY_ProgressBar, nWidth_ProgressBar, nHeight_ProgressBar, 15 ); +} + +} // namespace unocontrols + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |