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