framework/source/uielement/progressbarwrapper.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 <uielement/progressbarwrapper.hxx>
  21
  22 #include <helper/statusindicator.hxx>
  23 #include <uielement/statusindicatorinterfacewrapper.hxx>
  24
  25 #include <com/sun/star/ui/UIElementType.hpp>
  26 #include <com/sun/star/lang/DisposedException.hpp>
  27
  28 #include <vcl/status.hxx>
  29 #include <vcl/svapp.hxx>
  30 #include <toolkit/helper/vclunohelper.hxx>
  31
  32 using namespace ::com::sun::star;
  33
  34 namespace framework{
  35
  36 ProgressBarWrapper::ProgressBarWrapper() :
  37 UIElementWrapperBase( ::com::sun::star::ui::UIElementType::PROGRESSBAR )
  38     ,   m_bOwnsInstance( false )
  39     ,   m_nRange( 100 )
  40     ,   m_nValue( 0 )
  41 {
  42 }
  43
  44 ProgressBarWrapper::~ProgressBarWrapper()
  45 {
  46 }
  47
  48 // public interfaces
  49 void ProgressBarWrapper::setStatusBar( const uno::Reference< awt::XWindow >& rStatusBar, bool bOwnsInstance )
  50 {
  51     SolarMutexGuard g;
  52
  53     if ( m_bDisposed )
  54         return;
  55
  56     if ( m_bOwnsInstance )
  57     {
  58         // dispose XWindow reference our our status bar
  59         uno::Reference< lang::XComponent > xComponent( m_xStatusBar, uno::UNO_QUERY );
  60         try
  61         {
  62             if ( xComponent.is() )
  63                 xComponent->dispose();
  64         }
  65         catch ( const uno::Exception& )
  66         {
  67         }
  68         m_xStatusBar.clear();
  69     }
  70
  71     m_bOwnsInstance = bOwnsInstance;
  72     m_xStatusBar    = rStatusBar;
  73 }
  74
  75 uno::Reference< awt::XWindow > ProgressBarWrapper::getStatusBar() const
  76 {
  77     SolarMutexGuard g;
  78
  79     if ( m_bDisposed )
  80         return uno::Reference< awt::XWindow >();
  81
  82     return m_xStatusBar;
  83 }
  84
  85 // wrapped methods of ::com::sun::star::task::XStatusIndicator
  86 void ProgressBarWrapper::start( const OUString& Text, ::sal_Int32 Range )
  87     throw (uno::RuntimeException, std::exception)
  88 {
  89     uno::Reference< awt::XWindow > xWindow;
  90     sal_Int32                      nValue( 0 );
  91
  92     {
  93         SolarMutexGuard g;
  94
  95         if ( m_bDisposed )
  96             return;
  97
  98         xWindow  = m_xStatusBar;
  99         m_nValue = 0;
 100         m_nRange = Range;
 101         nValue   = m_nValue;
 102     }
 103
 104     if ( xWindow.is() )
 105     {
 106         SolarMutexGuard aSolarMutexGuard;
 107         vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
 108         if ( pWindow && pWindow->GetType() == WINDOW_STATUSBAR )
 109         {
 110             StatusBar* pStatusBar = static_cast<StatusBar *>(pWindow);
 111             if ( !pStatusBar->IsProgressMode() )
 112                 pStatusBar->StartProgressMode( Text );
 113             else
 114             {
 115                 pStatusBar->SetUpdateMode( false );
 116                 pStatusBar->EndProgressMode();
 117                 pStatusBar->StartProgressMode( Text );
 118                 pStatusBar->SetProgressValue( sal_uInt16( nValue ));
 119                 pStatusBar->SetUpdateMode( true );
 120             }
 121             pStatusBar->Show( true, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
 122         }
 123     }
 124 }
 125
 126 void ProgressBarWrapper::end()
 127     throw (uno::RuntimeException, std::exception)
 128 {
 129     uno::Reference< awt::XWindow > xWindow;
 130
 131     {
 132         SolarMutexGuard g;
 133
 134         if ( m_bDisposed )
 135             return;
 136
 137         xWindow  = m_xStatusBar;
 138         m_nRange = 100;
 139         m_nValue = 0;
 140     }
 141
 142     if ( xWindow.is() )
 143     {
 144         SolarMutexGuard aSolarMutexGuard;
 145         vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
 146         if ( pWindow && pWindow->GetType() == WINDOW_STATUSBAR )
 147         {
 148             StatusBar* pStatusBar = static_cast<StatusBar *>(pWindow);
 149             if ( pStatusBar->IsProgressMode() )
 150                 pStatusBar->EndProgressMode();
 151         }
 152     }
 153 }
 154
 155 void ProgressBarWrapper::setText( const OUString& Text )
 156     throw (uno::RuntimeException, std::exception)
 157 {
 158     uno::Reference< awt::XWindow > xWindow;
 159     sal_Int32 nValue( 0 );
 160
 161     {
 162         SolarMutexGuard g;
 163
 164         if ( m_bDisposed )
 165             return;
 166
 167         xWindow  = m_xStatusBar;
 168         m_aText  = Text;
 169         nValue   = m_nValue;
 170     }
 171
 172     if ( xWindow.is() )
 173     {
 174         SolarMutexGuard aSolarMutexGuard;
 175         vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
 176         if ( pWindow && pWindow->GetType() == WINDOW_STATUSBAR )
 177         {
 178             StatusBar* pStatusBar = static_cast<StatusBar *>(pWindow);
 179             if( pStatusBar->IsProgressMode() )
 180             {
 181                 pStatusBar->SetUpdateMode( false );
 182                 pStatusBar->EndProgressMode();
 183                 pStatusBar->StartProgressMode( Text );
 184                 pStatusBar->SetProgressValue( sal_uInt16( nValue ));
 185                 pStatusBar->SetUpdateMode( true );
 186             }
 187             else
 188                 pStatusBar->SetText( Text );
 189         }
 190     }
 191 }
 192
 193 void ProgressBarWrapper::setValue( ::sal_Int32 nValue )
 194     throw (uno::RuntimeException, std::exception)
 195 {
 196     uno::Reference< awt::XWindow > xWindow;
 197     OUString aText;
 198     bool      bSetValue( false );
 199
 200     {
 201         SolarMutexGuard g;
 202
 203         if ( m_bDisposed )
 204             return;
 205
 206         xWindow  = m_xStatusBar;
 207
 208         double fVal( 0 );
 209         if ( m_nRange > 0 )
 210         {
 211             fVal = ( double( nValue ) / double( m_nRange )) * 100;
 212             fVal = std::max( double( 0 ), std::min( fVal, double( 100 )));
 213         }
 214
 215         if ( m_nValue != sal_Int32( fVal ))
 216         {
 217             m_nValue = sal_Int32( fVal );
 218             bSetValue = true;
 219         }
 220
 221         nValue   = m_nValue;
 222         aText    = m_aText;
 223     }
 224
 225     if ( xWindow.is() && bSetValue )
 226     {
 227         SolarMutexGuard aSolarMutexGuard;
 228         vcl::Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
 229         if ( pWindow && pWindow->GetType() == WINDOW_STATUSBAR )
 230         {
 231             StatusBar* pStatusBar = static_cast<StatusBar *>(pWindow);
 232             if ( !pStatusBar->IsProgressMode() )
 233                 pStatusBar->StartProgressMode( aText );
 234             pStatusBar->SetProgressValue( sal_uInt16( nValue ));
 235         }
 236     }
 237 }
 238
 239 void ProgressBarWrapper::reset()
 240     throw (uno::RuntimeException, std::exception)
 241 {
 242     setText( OUString() );
 243     setValue( 0 );
 244 }
 245
 246 // XInitialization
 247 void SAL_CALL ProgressBarWrapper::initialize( const uno::Sequence< uno::Any >& )
 248 throw (uno::Exception, uno::RuntimeException, std::exception)
 249 {
 250     // dummy - do nothing
 251 }
 252
 253 // XUpdatable
 254 void SAL_CALL ProgressBarWrapper::update()
 255 throw (uno::RuntimeException, std::exception)
 256 {
 257     // dummy - do nothing
 258 }
 259
 260 // XComponent
 261 void SAL_CALL ProgressBarWrapper::dispose()
 262 throw (uno::RuntimeException, std::exception)
 263 {
 264     uno::Reference< lang::XComponent > xThis(
 265         static_cast< cppu::OWeakObject* >(this),
 266         uno::UNO_QUERY );
 267
 268     {
 269         SolarMutexGuard g;
 270
 271         if ( m_bDisposed )
 272             return;
 273     }
 274
 275     {
 276         lang::EventObject aEvent( xThis );
 277         m_aListenerContainer.disposeAndClear( aEvent );
 278
 279         SolarMutexGuard g;
 280         if ( m_bOwnsInstance )
 281         {
 282             try
 283             {
 284                 uno::Reference< lang::XComponent > xComponent( m_xStatusBar, uno::UNO_QUERY );
 285                 if ( xComponent.is() )
 286                     xComponent->dispose();
 287             }
 288             catch ( const lang::DisposedException& )
 289             {
 290             }
 291         }
 292
 293         m_xStatusBar.clear();
 294         m_bDisposed = true;
 295     }
 296 }
 297
 298 // XUIElement
 299 uno::Reference< uno::XInterface > SAL_CALL ProgressBarWrapper::getRealInterface()
 300 throw (uno::RuntimeException, std::exception)
 301 {
 302     SolarMutexGuard g;
 303
 304     if ( m_bDisposed )
 305         return uno::Reference< uno::XInterface >();
 306     else
 307     {
 308         uno::Reference< uno::XInterface > xComp( m_xProgressBarIfacWrapper );
 309         if ( !xComp.is() )
 310         {
 311             StatusIndicatorInterfaceWrapper* pWrapper =
 312                 new StatusIndicatorInterfaceWrapper(
 313                     uno::Reference< lang::XComponent >(
 314                         static_cast< cppu::OWeakObject* >( this ),
 315                         uno::UNO_QUERY ));
 316                 xComp = uno::Reference< uno::XInterface >(
 317                     static_cast< cppu::OWeakObject* >( pWrapper ),
 318                     uno::UNO_QUERY );
 319              m_xProgressBarIfacWrapper = xComp;
 320         }
 321
 322         return xComp;
 323     }
 324 }
 325
 326 }       //  namespace framework
 327
 328 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */