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 :
21 : #include <tools/debug.hxx>
22 : #include <vcl/fixedhyper.hxx>
23 : #include <vcl/prgsbar.hxx>
24 : #include <vcl/svapp.hxx>
25 : #include <svtools/svmedit.hxx>
26 : #include <unoiface.hxx>
27 : #include <svtools/filectrl.hxx>
28 : #include <svtools/roadmap.hxx>
29 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
30 : #include <com/sun/star/lang/XSingleServiceFactory.hpp>
31 : #include <com/sun/star/awt/LineEndFormat.hpp>
32 : #include <comphelper/processfactory.hxx>
33 : #include <toolkit/helper/convert.hxx>
34 : #include <toolkit/helper/property.hxx>
35 : #include <svtools/fmtfield.hxx>
36 : #include <svl/numuno.hxx>
37 : #include <svtools/calendar.hxx>
38 : #include <svtools/treelistbox.hxx>
39 : #include "treecontrolpeer.hxx"
40 : #include "svtxgridcontrol.hxx"
41 : #include <svtools/table/tablecontrol.hxx>
42 :
43 : namespace
44 : {
45 0 : static void lcl_setWinBits( Window* _pWindow, WinBits _nBits, sal_Bool _bSet )
46 : {
47 0 : WinBits nStyle = _pWindow->GetStyle();
48 0 : if ( _bSet )
49 0 : nStyle |= _nBits;
50 : else
51 0 : nStyle &= ~_nBits;
52 0 : _pWindow->SetStyle( nStyle );
53 0 : }
54 : }
55 :
56 : // ----------------------------------------------------
57 : // help function for the toolkit...
58 : // ----------------------------------------------------
59 :
60 : extern "C" {
61 :
62 2160 : SAL_DLLPUBLIC_EXPORT Window* CreateWindow( VCLXWindow** ppNewComp, const ::com::sun::star::awt::WindowDescriptor* pDescriptor, Window* pParent, WinBits nWinBits )
63 : {
64 2160 : Window* pWindow = NULL;
65 2160 : String aServiceName( pDescriptor->WindowServiceName );
66 2160 : if ( aServiceName.EqualsIgnoreCaseAscii( "MultiLineEdit" ) )
67 : {
68 0 : if ( pParent )
69 : {
70 0 : pWindow = new MultiLineEdit( pParent, nWinBits|WB_IGNORETAB);
71 0 : static_cast< MultiLineEdit* >( pWindow )->DisableSelectionOnFocus();
72 0 : *ppNewComp = new VCLXMultiLineEdit;
73 : }
74 : else
75 : {
76 0 : *ppNewComp = NULL;
77 0 : return NULL;
78 : }
79 : }
80 2160 : else if ( aServiceName.EqualsIgnoreCaseAscii( "FileControl" ) )
81 : {
82 0 : if ( pParent )
83 : {
84 0 : pWindow = new FileControl( pParent, nWinBits );
85 0 : *ppNewComp = new VCLXFileControl;
86 : }
87 : else
88 : {
89 0 : *ppNewComp = NULL;
90 0 : return NULL;
91 : }
92 : }
93 2160 : else if (aServiceName.EqualsIgnoreCaseAscii("FormattedField") )
94 : {
95 0 : pWindow = new FormattedField( pParent, nWinBits );
96 0 : *ppNewComp = new SVTXFormattedField;
97 : }
98 2160 : else if (aServiceName.EqualsIgnoreCaseAscii("NumericField") )
99 : {
100 0 : pWindow = new DoubleNumericField( pParent, nWinBits );
101 0 : *ppNewComp = new SVTXNumericField;
102 : }
103 2160 : else if (aServiceName.EqualsIgnoreCaseAscii("LongCurrencyField") )
104 : {
105 0 : pWindow = new DoubleCurrencyField( pParent, nWinBits );
106 0 : *ppNewComp = new SVTXCurrencyField;
107 : }
108 2160 : else if (aServiceName.EqualsIgnoreCaseAscii("datefield") )
109 : {
110 0 : pWindow = new CalendarField( pParent, nWinBits);
111 0 : static_cast<CalendarField*>(pWindow)->EnableToday();
112 0 : static_cast<CalendarField*>(pWindow)->EnableNone();
113 0 : static_cast<CalendarField*>(pWindow)->EnableEmptyFieldValue( sal_True );
114 0 : *ppNewComp = new SVTXDateField;
115 0 : ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(DateField*)pWindow );
116 : }
117 2160 : else if (aServiceName.EqualsIgnoreCaseAscii("roadmap") )
118 : {
119 0 : pWindow = new ::svt::ORoadmap( pParent, WB_TABSTOP );
120 0 : *ppNewComp = new SVTXRoadmap;
121 : }
122 2160 : else if ( aServiceName.EqualsIgnoreCaseAscii( "ProgressBar" ) )
123 : {
124 0 : if ( pParent )
125 : {
126 0 : pWindow = new ProgressBar( pParent, nWinBits );
127 0 : *ppNewComp = new VCLXProgressBar;
128 : }
129 : else
130 : {
131 0 : *ppNewComp = NULL;
132 0 : return NULL;
133 : }
134 : }
135 2160 : else if ( aServiceName.EqualsIgnoreCaseAscii( "Tree" ) )
136 : {
137 0 : TreeControlPeer* pPeer = new TreeControlPeer;
138 0 : *ppNewComp = pPeer;
139 0 : pWindow = pPeer->createVclControl( pParent, nWinBits );
140 : }
141 2160 : else if ( aServiceName.EqualsIgnoreCaseAscii( "FixedHyperlink" ) )
142 : {
143 0 : if ( pParent )
144 : {
145 0 : pWindow = new FixedHyperlink( pParent, nWinBits );
146 0 : *ppNewComp = new VCLXFixedHyperlink;
147 : }
148 : else
149 : {
150 0 : *ppNewComp = NULL;
151 0 : return NULL;
152 : }
153 : }
154 2160 : else if ( aServiceName.EqualsIgnoreCaseAscii( "Grid" ) )
155 : {
156 0 : if ( pParent )
157 : {
158 0 : pWindow = new ::svt::table::TableControl(pParent, nWinBits);
159 0 : *ppNewComp = new SVTXGridControl;
160 : }
161 : else
162 : {
163 0 : *ppNewComp = NULL;
164 0 : return NULL;
165 : }
166 : }
167 2160 : return pWindow;
168 : }
169 :
170 : } // extern "C"
171 :
172 : // ----------------------------------------------------
173 : // class VCLXMultiLineEdit
174 : // ----------------------------------------------------
175 0 : VCLXMultiLineEdit::VCLXMultiLineEdit()
176 : :maTextListeners( *this )
177 0 : ,meLineEndType( LINEEND_LF ) // default behavior before introducing this property: LF (unix-like)
178 : {
179 0 : }
180 :
181 0 : VCLXMultiLineEdit::~VCLXMultiLineEdit()
182 : {
183 0 : }
184 :
185 0 : ::com::sun::star::uno::Any VCLXMultiLineEdit::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
186 : {
187 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
188 : (static_cast< ::com::sun::star::awt::XTextComponent* >(this)),
189 : (static_cast< ::com::sun::star::awt::XTextArea* >(this)),
190 : (static_cast< ::com::sun::star::awt::XTextLayoutConstrains* >(this)),
191 0 : (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
192 0 : return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
193 : }
194 :
195 : // ::com::sun::star::lang::XTypeProvider
196 0 : IMPL_XTYPEPROVIDER_START( VCLXMultiLineEdit )
197 0 : getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextComponent>* ) NULL ),
198 0 : getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextArea>* ) NULL ),
199 0 : getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextLayoutConstrains>* ) NULL ),
200 : VCLXWindow::getTypes()
201 0 : IMPL_XTYPEPROVIDER_END
202 :
203 0 : void VCLXMultiLineEdit::addTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
204 : {
205 0 : maTextListeners.addInterface( l );
206 0 : }
207 :
208 0 : void VCLXMultiLineEdit::removeTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
209 : {
210 0 : maTextListeners.removeInterface( l );
211 0 : }
212 :
213 0 : void VCLXMultiLineEdit::setText( const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
214 : {
215 0 : SolarMutexGuard aGuard;
216 :
217 0 : MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow();
218 0 : if ( pEdit )
219 : {
220 0 : pEdit->SetText( aText );
221 :
222 : // #107218# Call same listeners like VCL would do after user interaction
223 0 : SetSynthesizingVCLEvent( sal_True );
224 0 : pEdit->SetModifyFlag();
225 0 : pEdit->Modify();
226 0 : SetSynthesizingVCLEvent( sal_False );
227 0 : }
228 0 : }
229 :
230 0 : void VCLXMultiLineEdit::insertText( const ::com::sun::star::awt::Selection& rSel, const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
231 : {
232 0 : SolarMutexGuard aGuard;
233 :
234 0 : MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow();
235 0 : if ( pEdit )
236 : {
237 0 : setSelection( rSel );
238 0 : pEdit->ReplaceSelected( aText );
239 0 : }
240 0 : }
241 :
242 0 : ::rtl::OUString VCLXMultiLineEdit::getText() throw(::com::sun::star::uno::RuntimeException)
243 : {
244 0 : SolarMutexGuard aGuard;
245 :
246 0 : ::rtl::OUString aText;
247 0 : MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow();
248 0 : if ( pEdit )
249 0 : aText = pEdit->GetText( meLineEndType );
250 0 : return aText;
251 : }
252 :
253 0 : ::rtl::OUString VCLXMultiLineEdit::getSelectedText() throw(::com::sun::star::uno::RuntimeException)
254 : {
255 0 : SolarMutexGuard aGuard;
256 :
257 0 : ::rtl::OUString aText;
258 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
259 0 : if ( pMultiLineEdit)
260 0 : aText = pMultiLineEdit->GetSelected( meLineEndType );
261 0 : return aText;
262 :
263 : }
264 :
265 0 : void VCLXMultiLineEdit::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw(::com::sun::star::uno::RuntimeException)
266 : {
267 0 : SolarMutexGuard aGuard;
268 :
269 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
270 0 : if ( pMultiLineEdit )
271 : {
272 0 : pMultiLineEdit->SetSelection( Selection( aSelection.Min, aSelection.Max ) );
273 0 : }
274 0 : }
275 :
276 0 : ::com::sun::star::awt::Selection VCLXMultiLineEdit::getSelection() throw(::com::sun::star::uno::RuntimeException)
277 : {
278 0 : SolarMutexGuard aGuard;
279 :
280 0 : ::com::sun::star::awt::Selection aSel;
281 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
282 0 : if ( pMultiLineEdit )
283 : {
284 0 : aSel.Min = pMultiLineEdit->GetSelection().Min();
285 0 : aSel.Max = pMultiLineEdit->GetSelection().Max();
286 : }
287 0 : return aSel;
288 : }
289 :
290 0 : sal_Bool VCLXMultiLineEdit::isEditable() throw(::com::sun::star::uno::RuntimeException)
291 : {
292 0 : SolarMutexGuard aGuard;
293 :
294 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
295 0 : return ( pMultiLineEdit && !pMultiLineEdit->IsReadOnly() && pMultiLineEdit->IsEnabled() ) ? sal_True : sal_False;
296 : }
297 :
298 0 : void VCLXMultiLineEdit::setEditable( sal_Bool bEditable ) throw(::com::sun::star::uno::RuntimeException)
299 : {
300 0 : SolarMutexGuard aGuard;
301 :
302 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
303 0 : if ( pMultiLineEdit )
304 0 : pMultiLineEdit->SetReadOnly( !bEditable );
305 0 : }
306 :
307 0 : void VCLXMultiLineEdit::setMaxTextLen( sal_Int16 nLen ) throw(::com::sun::star::uno::RuntimeException)
308 : {
309 0 : SolarMutexGuard aGuard;
310 :
311 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
312 0 : if ( pMultiLineEdit )
313 0 : pMultiLineEdit->SetMaxTextLen( nLen );
314 0 : }
315 :
316 0 : sal_Int16 VCLXMultiLineEdit::getMaxTextLen() throw(::com::sun::star::uno::RuntimeException)
317 : {
318 0 : SolarMutexGuard aGuard;
319 :
320 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*) GetWindow();
321 0 : return pMultiLineEdit ? (sal_Int16)pMultiLineEdit->GetMaxTextLen() : (sal_Int16)0;
322 : }
323 :
324 0 : ::rtl::OUString VCLXMultiLineEdit::getTextLines() throw(::com::sun::star::uno::RuntimeException)
325 : {
326 0 : SolarMutexGuard aGuard;
327 :
328 0 : ::rtl::OUString aText;
329 0 : MultiLineEdit* pEdit = (MultiLineEdit*)GetWindow();
330 0 : if ( pEdit )
331 0 : aText = pEdit->GetTextLines( meLineEndType );
332 0 : return aText;
333 : }
334 :
335 0 : ::com::sun::star::awt::Size VCLXMultiLineEdit::getMinimumSize() throw(::com::sun::star::uno::RuntimeException)
336 : {
337 0 : SolarMutexGuard aGuard;
338 :
339 0 : ::com::sun::star::awt::Size aSz;
340 0 : MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
341 0 : if ( pEdit )
342 0 : aSz = AWTSize(pEdit->CalcMinimumSize());
343 0 : return aSz;
344 : }
345 :
346 0 : ::com::sun::star::awt::Size VCLXMultiLineEdit::getPreferredSize() throw(::com::sun::star::uno::RuntimeException)
347 : {
348 0 : return getMinimumSize();
349 : }
350 :
351 0 : ::com::sun::star::awt::Size VCLXMultiLineEdit::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
352 : {
353 0 : SolarMutexGuard aGuard;
354 :
355 0 : ::com::sun::star::awt::Size aSz = rNewSize;
356 0 : MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
357 0 : if ( pEdit )
358 0 : aSz = AWTSize(pEdit->CalcAdjustedSize( VCLSize(rNewSize )));
359 0 : return aSz;
360 : }
361 :
362 0 : ::com::sun::star::awt::Size VCLXMultiLineEdit::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException)
363 : {
364 0 : SolarMutexGuard aGuard;
365 :
366 0 : ::com::sun::star::awt::Size aSz;
367 0 : MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
368 0 : if ( pEdit )
369 0 : aSz = AWTSize(pEdit->CalcSize( nCols, nLines ));
370 0 : return aSz;
371 : }
372 :
373 0 : void VCLXMultiLineEdit::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException)
374 : {
375 0 : SolarMutexGuard aGuard;
376 :
377 0 : nCols = nLines = 0;
378 0 : MultiLineEdit* pEdit = (MultiLineEdit*) GetWindow();
379 0 : if ( pEdit )
380 : {
381 : sal_uInt16 nC, nL;
382 0 : pEdit->GetMaxVisColumnsAndLines( nC, nL );
383 0 : nCols = nC;
384 0 : nLines = nL;
385 0 : }
386 0 : }
387 :
388 0 : void VCLXMultiLineEdit::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
389 : {
390 0 : switch ( rVclWindowEvent.GetId() )
391 : {
392 : case VCLEVENT_EDIT_MODIFY:
393 : {
394 0 : if ( maTextListeners.getLength() )
395 : {
396 0 : ::com::sun::star::awt::TextEvent aEvent;
397 0 : aEvent.Source = (::cppu::OWeakObject*)this;
398 0 : maTextListeners.textChanged( aEvent );
399 : }
400 : }
401 0 : break;
402 : default:
403 : {
404 0 : VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
405 : }
406 0 : break;
407 : }
408 0 : }
409 :
410 0 : void VCLXMultiLineEdit::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
411 : {
412 0 : SolarMutexGuard aGuard;
413 :
414 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*)GetWindow();
415 0 : if ( pMultiLineEdit )
416 : {
417 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
418 0 : switch ( nPropType )
419 : {
420 : case BASEPROPERTY_LINE_END_FORMAT:
421 : {
422 0 : sal_Int16 nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED;
423 0 : OSL_VERIFY( Value >>= nLineEndType );
424 0 : switch ( nLineEndType )
425 : {
426 0 : case ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN: meLineEndType = LINEEND_CR; break;
427 0 : case ::com::sun::star::awt::LineEndFormat::LINE_FEED: meLineEndType = LINEEND_LF; break;
428 0 : case ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN_LINE_FEED: meLineEndType = LINEEND_CRLF; break;
429 0 : default: OSL_FAIL( "VCLXMultiLineEdit::setProperty: invalid line end value!" ); break;
430 : }
431 : }
432 0 : break;
433 :
434 : case BASEPROPERTY_READONLY:
435 : {
436 0 : sal_Bool b = sal_Bool();
437 0 : if ( Value >>= b )
438 0 : pMultiLineEdit->SetReadOnly( b );
439 : }
440 0 : break;
441 : case BASEPROPERTY_MAXTEXTLEN:
442 : {
443 0 : sal_Int16 n = sal_Int16();
444 0 : if ( Value >>= n )
445 0 : pMultiLineEdit->SetMaxTextLen( n );
446 : }
447 0 : break;
448 : case BASEPROPERTY_HIDEINACTIVESELECTION:
449 : {
450 0 : sal_Bool b = sal_Bool();
451 0 : if ( Value >>= b )
452 : {
453 0 : pMultiLineEdit->EnableFocusSelectionHide( b );
454 0 : lcl_setWinBits( pMultiLineEdit, WB_NOHIDESELECTION, !b );
455 : }
456 : }
457 0 : break;
458 : default:
459 : {
460 0 : VCLXWindow::setProperty( PropertyName, Value );
461 : }
462 : }
463 0 : }
464 0 : }
465 :
466 0 : ::com::sun::star::uno::Any VCLXMultiLineEdit::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
467 : {
468 0 : SolarMutexGuard aGuard;
469 :
470 0 : ::com::sun::star::uno::Any aProp;
471 0 : MultiLineEdit* pMultiLineEdit = (MultiLineEdit*)GetWindow();
472 0 : if ( pMultiLineEdit )
473 : {
474 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
475 0 : switch ( nPropType )
476 : {
477 : case BASEPROPERTY_LINE_END_FORMAT:
478 : {
479 0 : sal_Int16 nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED;
480 0 : switch ( meLineEndType )
481 : {
482 0 : case LINEEND_CR: nLineEndType = ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN; break;
483 0 : case LINEEND_LF: nLineEndType = ::com::sun::star::awt::LineEndFormat::LINE_FEED; break;
484 0 : case LINEEND_CRLF: nLineEndType = ::com::sun::star::awt::LineEndFormat::CARRIAGE_RETURN_LINE_FEED; break;
485 0 : default: OSL_FAIL( "VCLXMultiLineEdit::getProperty: invalid line end value!" ); break;
486 : }
487 0 : aProp <<= nLineEndType;
488 : }
489 0 : break;
490 :
491 : case BASEPROPERTY_READONLY:
492 : {
493 0 : aProp <<= pMultiLineEdit->IsReadOnly();
494 : }
495 0 : break;
496 : case BASEPROPERTY_MAXTEXTLEN:
497 : {
498 0 : aProp <<= (sal_Int16) pMultiLineEdit->GetMaxTextLen();
499 : }
500 0 : break;
501 : default:
502 : {
503 0 : aProp <<= VCLXWindow::getProperty( PropertyName );
504 : }
505 : }
506 : }
507 0 : return aProp;
508 : }
509 :
510 0 : void SAL_CALL VCLXMultiLineEdit::setFocus( ) throw(::com::sun::star::uno::RuntimeException)
511 : {
512 0 : SolarMutexGuard aGuard;
513 :
514 : // don't grab the focus if we already have it. Reason is that the only thing which the edit
515 : // does is forwarding the focus to it's text window. This text window then does a "select all".
516 : // So if the text window already has the focus, and we give the focus to the multi line
517 : // edit, then all which happens is that everything is selected.
518 : // #i27072#
519 0 : if ( GetWindow() && !GetWindow()->HasChildPathFocus() )
520 0 : GetWindow()->GrabFocus();
521 0 : }
522 :
523 0 : void VCLXMultiLineEdit::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
524 : {
525 : PushPropertyIds( rIds,
526 : // FIXME: elide duplication ?
527 : BASEPROPERTY_LINE_END_FORMAT,
528 : BASEPROPERTY_READONLY,
529 : BASEPROPERTY_MAXTEXTLEN,
530 : BASEPROPERTY_HIDEINACTIVESELECTION,
531 0 : 0);
532 0 : VCLXWindow::ImplGetPropertyIds( rIds, true );
533 :
534 0 : }
535 : // ----------------------------------------------------
536 : // class VCLXFileControl
537 : // ----------------------------------------------------
538 0 : VCLXFileControl::VCLXFileControl() : maTextListeners( *this )
539 : {
540 0 : }
541 :
542 0 : VCLXFileControl::~VCLXFileControl()
543 : {
544 0 : FileControl* pControl = (FileControl*) GetWindow();
545 0 : if ( pControl )
546 0 : pControl->GetEdit().SetModifyHdl( Link() );
547 0 : }
548 :
549 0 : ::com::sun::star::uno::Any VCLXFileControl::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
550 : {
551 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
552 : (static_cast< ::com::sun::star::awt::XTextComponent* >(this)),
553 : (static_cast< ::com::sun::star::awt::XTextLayoutConstrains* >(this)),
554 0 : (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
555 0 : return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
556 : }
557 :
558 : // ::com::sun::star::lang::XTypeProvider
559 0 : IMPL_XTYPEPROVIDER_START( VCLXFileControl )
560 0 : getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextComponent>* ) NULL ),
561 0 : getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextLayoutConstrains>* ) NULL ),
562 : VCLXWindow::getTypes()
563 0 : IMPL_XTYPEPROVIDER_END
564 :
565 0 : void SAL_CALL VCLXFileControl::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
566 : {
567 0 : SolarMutexGuard aGuard;
568 :
569 0 : FileControl* pControl = (FileControl*)GetWindow();
570 0 : if ( pControl )
571 : {
572 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
573 0 : switch ( nPropType )
574 : {
575 : case BASEPROPERTY_HIDEINACTIVESELECTION:
576 : {
577 0 : sal_Bool bValue( sal_False );
578 0 : OSL_VERIFY( Value >>= bValue );
579 :
580 0 : lcl_setWinBits( pControl, WB_NOHIDESELECTION, !bValue );
581 0 : lcl_setWinBits( &pControl->GetEdit(), WB_NOHIDESELECTION, !bValue );
582 : }
583 0 : break;
584 :
585 : default:
586 0 : VCLXWindow::setProperty( PropertyName, Value );
587 0 : break;
588 : }
589 0 : }
590 0 : }
591 :
592 0 : void VCLXFileControl::SetWindow( Window* pWindow )
593 : {
594 0 : FileControl* pPrevFileControl = dynamic_cast<FileControl*>( GetWindow() );
595 0 : if ( pPrevFileControl )
596 0 : pPrevFileControl->GetEdit().SetModifyHdl( Link() );
597 :
598 0 : FileControl* pNewFileControl = dynamic_cast<FileControl*>( pWindow );
599 0 : if ( pNewFileControl )
600 0 : pNewFileControl->GetEdit().SetModifyHdl( LINK( this, VCLXFileControl, ModifyHdl ) );
601 :
602 0 : VCLXWindow::SetWindow( pWindow );
603 0 : }
604 :
605 0 : void VCLXFileControl::addTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
606 : {
607 0 : maTextListeners.addInterface( l );
608 0 : }
609 :
610 0 : void VCLXFileControl::removeTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException)
611 : {
612 0 : maTextListeners.removeInterface( l );
613 0 : }
614 :
615 0 : void VCLXFileControl::setText( const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
616 : {
617 0 : SolarMutexGuard aGuard;
618 :
619 0 : Window* pWindow = GetWindow();
620 0 : if ( pWindow )
621 : {
622 0 : pWindow->SetText( aText );
623 :
624 : // In JAVA wird auch ein textChanged ausgeloest, in VCL nicht.
625 : // ::com::sun::star::awt::Toolkit soll JAVA-komform sein...
626 0 : ModifyHdl( NULL );
627 0 : }
628 0 : }
629 :
630 0 : void VCLXFileControl::insertText( const ::com::sun::star::awt::Selection& rSel, const ::rtl::OUString& aText ) throw(::com::sun::star::uno::RuntimeException)
631 : {
632 0 : SolarMutexGuard aGuard;
633 :
634 0 : FileControl* pFileControl = (FileControl*) GetWindow();
635 0 : if ( pFileControl )
636 : {
637 0 : pFileControl->GetEdit().SetSelection( Selection( rSel.Min, rSel.Max ) );
638 0 : pFileControl->GetEdit().ReplaceSelected( aText );
639 0 : }
640 0 : }
641 :
642 0 : ::rtl::OUString VCLXFileControl::getText() throw(::com::sun::star::uno::RuntimeException)
643 : {
644 0 : SolarMutexGuard aGuard;
645 :
646 0 : ::rtl::OUString aText;
647 0 : Window* pWindow = GetWindow();
648 0 : if ( pWindow )
649 0 : aText = pWindow->GetText();
650 0 : return aText;
651 : }
652 :
653 0 : ::rtl::OUString VCLXFileControl::getSelectedText() throw(::com::sun::star::uno::RuntimeException)
654 : {
655 0 : SolarMutexGuard aGuard;
656 :
657 0 : ::rtl::OUString aText;
658 0 : FileControl* pFileControl = (FileControl*) GetWindow();
659 0 : if ( pFileControl)
660 0 : aText = pFileControl->GetEdit().GetSelected();
661 0 : return aText;
662 :
663 : }
664 :
665 0 : void VCLXFileControl::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw(::com::sun::star::uno::RuntimeException)
666 : {
667 0 : SolarMutexGuard aGuard;
668 :
669 0 : FileControl* pFileControl = (FileControl*) GetWindow();
670 0 : if ( pFileControl )
671 0 : pFileControl->GetEdit().SetSelection( Selection( aSelection.Min, aSelection.Max ) );
672 0 : }
673 :
674 0 : ::com::sun::star::awt::Selection VCLXFileControl::getSelection() throw(::com::sun::star::uno::RuntimeException)
675 : {
676 0 : SolarMutexGuard aGuard;
677 :
678 0 : ::com::sun::star::awt::Selection aSel;
679 0 : FileControl* pFileControl = (FileControl*) GetWindow();
680 0 : if ( pFileControl )
681 : {
682 0 : aSel.Min = pFileControl->GetEdit().GetSelection().Min();
683 0 : aSel.Max = pFileControl->GetEdit().GetSelection().Max();
684 : }
685 0 : return aSel;
686 : }
687 :
688 0 : sal_Bool VCLXFileControl::isEditable() throw(::com::sun::star::uno::RuntimeException)
689 : {
690 0 : SolarMutexGuard aGuard;
691 :
692 0 : FileControl* pFileControl = (FileControl*) GetWindow();
693 0 : return ( pFileControl && !pFileControl->GetEdit().IsReadOnly() && pFileControl->GetEdit().IsEnabled() ) ? sal_True : sal_False;
694 : }
695 :
696 0 : void VCLXFileControl::setEditable( sal_Bool bEditable ) throw(::com::sun::star::uno::RuntimeException)
697 : {
698 0 : SolarMutexGuard aGuard;
699 :
700 0 : FileControl* pFileControl = (FileControl*) GetWindow();
701 0 : if ( pFileControl )
702 0 : pFileControl->GetEdit().SetReadOnly( !bEditable );
703 0 : }
704 :
705 0 : void VCLXFileControl::setMaxTextLen( sal_Int16 nLen ) throw(::com::sun::star::uno::RuntimeException)
706 : {
707 0 : SolarMutexGuard aGuard;
708 :
709 0 : FileControl* pFileControl = (FileControl*) GetWindow();
710 0 : if ( pFileControl )
711 0 : pFileControl->GetEdit().SetMaxTextLen( nLen );
712 0 : }
713 :
714 0 : sal_Int16 VCLXFileControl::getMaxTextLen() throw(::com::sun::star::uno::RuntimeException)
715 : {
716 0 : SolarMutexGuard aGuard;
717 :
718 0 : FileControl* pFileControl = (FileControl*) GetWindow();
719 0 : return pFileControl ? pFileControl->GetEdit().GetMaxTextLen() : 0;
720 : }
721 :
722 :
723 0 : IMPL_LINK_NOARG(VCLXFileControl, ModifyHdl)
724 : {
725 0 : ::com::sun::star::awt::TextEvent aEvent;
726 0 : aEvent.Source = (::cppu::OWeakObject*)this;
727 0 : maTextListeners.textChanged( aEvent );
728 :
729 0 : return 1;
730 : }
731 :
732 0 : ::com::sun::star::awt::Size VCLXFileControl::getMinimumSize() throw(::com::sun::star::uno::RuntimeException)
733 : {
734 0 : SolarMutexGuard aGuard;
735 :
736 0 : ::com::sun::star::awt::Size aSz;
737 0 : FileControl* pControl = (FileControl*) GetWindow();
738 0 : if ( pControl )
739 : {
740 0 : Size aTmpSize = pControl->GetEdit().CalcMinimumSize();
741 0 : aTmpSize.Width() += pControl->GetButton().CalcMinimumSize().Width();
742 0 : aSz = AWTSize(pControl->CalcWindowSize( aTmpSize ));
743 : }
744 0 : return aSz;
745 : }
746 :
747 0 : ::com::sun::star::awt::Size VCLXFileControl::getPreferredSize() throw(::com::sun::star::uno::RuntimeException)
748 : {
749 0 : ::com::sun::star::awt::Size aSz = getMinimumSize();
750 0 : aSz.Height += 4;
751 0 : return aSz;
752 : }
753 :
754 0 : ::com::sun::star::awt::Size VCLXFileControl::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
755 : {
756 0 : SolarMutexGuard aGuard;
757 :
758 0 : ::com::sun::star::awt::Size aSz =rNewSize;
759 0 : FileControl* pControl = (FileControl*) GetWindow();
760 0 : if ( pControl )
761 : {
762 0 : ::com::sun::star::awt::Size aMinSz = getMinimumSize();
763 0 : if ( aSz.Height != aMinSz.Height )
764 0 : aSz.Height = aMinSz.Height;
765 : }
766 0 : return aSz;
767 : }
768 :
769 0 : ::com::sun::star::awt::Size VCLXFileControl::getMinimumSize( sal_Int16 nCols, sal_Int16 ) throw(::com::sun::star::uno::RuntimeException)
770 : {
771 0 : SolarMutexGuard aGuard;
772 :
773 0 : ::com::sun::star::awt::Size aSz;
774 0 : FileControl* pControl = (FileControl*) GetWindow();
775 0 : if ( pControl )
776 : {
777 0 : aSz = AWTSize(pControl->GetEdit().CalcSize( nCols ));
778 0 : aSz.Width += pControl->GetButton().CalcMinimumSize().Width();
779 : }
780 0 : return aSz;
781 : }
782 :
783 0 : void VCLXFileControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException)
784 : {
785 0 : SolarMutexGuard aGuard;
786 :
787 0 : nCols = 0;
788 0 : nLines = 1;
789 0 : FileControl* pControl = (FileControl*) GetWindow();
790 0 : if ( pControl )
791 0 : nCols = (sal_Int16) pControl->GetEdit().GetMaxVisChars();
792 0 : }
793 :
794 0 : void VCLXFileControl::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
795 : {
796 : PushPropertyIds( rIds,
797 : // FIXME: elide duplication ?
798 : BASEPROPERTY_HIDEINACTIVESELECTION,
799 0 : 0);
800 0 : VCLXWindow::ImplGetPropertyIds( rIds, true );
801 0 : }
802 :
803 :
804 : // ----------------------------------------------------
805 : // class SVTXFormattedField
806 : // ----------------------------------------------------
807 : // --------------------------------------------------------------------------------------
808 0 : SVTXFormattedField::SVTXFormattedField()
809 : :m_pCurrentSupplier(NULL)
810 : ,bIsStandardSupplier(sal_True)
811 0 : ,nKeyToSetDelayed(-1)
812 : {
813 0 : }
814 :
815 : // --------------------------------------------------------------------------------------
816 0 : SVTXFormattedField::~SVTXFormattedField()
817 : {
818 0 : if (m_pCurrentSupplier)
819 : {
820 0 : m_pCurrentSupplier->release();
821 0 : m_pCurrentSupplier = NULL;
822 : }
823 0 : }
824 :
825 : // --------------------------------------------------------------------------------------
826 0 : void SVTXFormattedField::SetWindow( Window* _pWindow )
827 : {
828 0 : VCLXSpinField::SetWindow(_pWindow);
829 0 : if (GetFormattedField())
830 0 : GetFormattedField()->SetAutoColor(sal_True);
831 0 : }
832 :
833 : // --------------------------------------------------------------------------------------
834 0 : void SVTXFormattedField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
835 : {
836 0 : SolarMutexGuard aGuard;
837 :
838 0 : FormattedField* pField = GetFormattedField();
839 0 : if ( pField )
840 : {
841 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
842 0 : switch (nPropType)
843 : {
844 : case BASEPROPERTY_ENFORCE_FORMAT:
845 : {
846 0 : sal_Bool bEnable( sal_True );
847 0 : if ( Value >>= bEnable )
848 0 : pField->EnableNotANumber( !bEnable );
849 : }
850 0 : break;
851 :
852 : case BASEPROPERTY_EFFECTIVE_MIN:
853 : case BASEPROPERTY_VALUEMIN_DOUBLE:
854 0 : SetMinValue(Value);
855 0 : break;
856 :
857 : case BASEPROPERTY_EFFECTIVE_MAX:
858 : case BASEPROPERTY_VALUEMAX_DOUBLE:
859 0 : SetMaxValue(Value);
860 0 : break;
861 :
862 : case BASEPROPERTY_EFFECTIVE_DEFAULT:
863 0 : SetDefaultValue(Value);
864 0 : break;
865 :
866 : case BASEPROPERTY_TREATASNUMBER:
867 : {
868 0 : sal_Bool b = sal_Bool();
869 0 : if ( Value >>= b )
870 0 : SetTreatAsNumber(b);
871 : }
872 0 : break;
873 :
874 : case BASEPROPERTY_FORMATSSUPPLIER:
875 0 : if (!Value.hasValue())
876 0 : setFormatsSupplier(::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > (NULL));
877 : else
878 : {
879 0 : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > xNFS;
880 0 : if ( Value >>= xNFS )
881 0 : setFormatsSupplier(xNFS);
882 : }
883 0 : break;
884 : case BASEPROPERTY_FORMATKEY:
885 0 : if (!Value.hasValue())
886 0 : setFormatKey(0);
887 : else
888 : {
889 0 : sal_Int32 n = 0;
890 0 : if ( Value >>= n )
891 0 : setFormatKey(n);
892 : }
893 0 : break;
894 :
895 : case BASEPROPERTY_EFFECTIVE_VALUE:
896 : case BASEPROPERTY_VALUE_DOUBLE:
897 : {
898 0 : const ::com::sun::star::uno::TypeClass rTC = Value.getValueType().getTypeClass();
899 0 : if (rTC != ::com::sun::star::uno::TypeClass_STRING)
900 : // no string
901 0 : if (rTC != ::com::sun::star::uno::TypeClass_DOUBLE)
902 : // no double
903 0 : if (Value.hasValue())
904 : { // but a value
905 : // try if it is something converitble
906 0 : sal_Int32 nValue = 0;
907 0 : if (!(Value >>= nValue))
908 0 : throw ::com::sun::star::lang::IllegalArgumentException();
909 0 : SetValue(::com::sun::star::uno::makeAny((double)nValue));
910 : break;
911 : }
912 :
913 0 : SetValue(Value);
914 : }
915 0 : break;
916 : case BASEPROPERTY_VALUESTEP_DOUBLE:
917 : {
918 0 : double d = 0.0;
919 0 : if ( Value >>= d )
920 0 : pField->SetSpinSize( d );
921 : else
922 : {
923 0 : sal_Int32 n = 0;
924 0 : if ( Value >>= n )
925 0 : pField->SetSpinSize( n );
926 : }
927 : }
928 0 : break;
929 : case BASEPROPERTY_DECIMALACCURACY:
930 : {
931 0 : sal_Int32 n = 0;
932 0 : if ( Value >>= n )
933 0 : pField->SetDecimalDigits( (sal_uInt16)n );
934 : }
935 0 : break;
936 : case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
937 : {
938 0 : sal_Bool b = sal_Bool();
939 0 : if ( Value >>= b )
940 0 : pField->SetThousandsSep( b );
941 : }
942 0 : break;
943 :
944 : default:
945 0 : VCLXSpinField::setProperty( PropertyName, Value );
946 : }
947 :
948 0 : if (BASEPROPERTY_TEXTCOLOR == nPropType)
949 : { // after setting a new text color, think again about the AutoColor flag of the control
950 : // 17.05.2001 - 86859 - frank.schoenheit@germany.sun.com
951 0 : pField->SetAutoColor(!Value.hasValue());
952 : }
953 : }
954 : else
955 0 : VCLXSpinField::setProperty( PropertyName, Value );
956 0 : }
957 :
958 : // --------------------------------------------------------------------------------------
959 0 : ::com::sun::star::uno::Any SVTXFormattedField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
960 : {
961 0 : SolarMutexGuard aGuard;
962 :
963 0 : ::com::sun::star::uno::Any aReturn;
964 :
965 0 : FormattedField* pField = GetFormattedField();
966 0 : if ( pField )
967 : {
968 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
969 0 : switch (nPropType)
970 : {
971 : case BASEPROPERTY_EFFECTIVE_MIN:
972 : case BASEPROPERTY_VALUEMIN_DOUBLE:
973 0 : aReturn <<= GetMinValue();
974 0 : break;
975 :
976 : case BASEPROPERTY_EFFECTIVE_MAX:
977 : case BASEPROPERTY_VALUEMAX_DOUBLE:
978 0 : aReturn <<= GetMaxValue();
979 0 : break;
980 :
981 : case BASEPROPERTY_EFFECTIVE_DEFAULT:
982 0 : aReturn <<= GetDefaultValue();
983 0 : break;
984 :
985 : case BASEPROPERTY_TREATASNUMBER:
986 0 : aReturn <<= GetTreatAsNumber();
987 0 : break;
988 :
989 : case BASEPROPERTY_EFFECTIVE_VALUE:
990 : case BASEPROPERTY_VALUE_DOUBLE:
991 0 : aReturn <<= GetValue();
992 0 : break;
993 :
994 : case BASEPROPERTY_VALUESTEP_DOUBLE:
995 0 : aReturn <<= pField->GetSpinSize();
996 0 : break;
997 :
998 : case BASEPROPERTY_DECIMALACCURACY:
999 0 : aReturn <<= pField->GetDecimalDigits();
1000 0 : break;
1001 :
1002 : case BASEPROPERTY_FORMATSSUPPLIER:
1003 : {
1004 0 : if (!bIsStandardSupplier)
1005 : { // ansonsten void
1006 0 : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > xSupplier = getFormatsSupplier();
1007 0 : aReturn <<= xSupplier;
1008 : }
1009 : }
1010 0 : break;
1011 :
1012 : case BASEPROPERTY_FORMATKEY:
1013 : {
1014 0 : if (!bIsStandardSupplier)
1015 0 : aReturn <<= getFormatKey();
1016 : }
1017 0 : break;
1018 :
1019 : default:
1020 0 : aReturn <<= VCLXSpinField::getProperty(PropertyName);
1021 : }
1022 : }
1023 0 : return aReturn;
1024 : }
1025 :
1026 : // --------------------------------------------------------------------------------------
1027 0 : ::com::sun::star::uno::Any SVTXFormattedField::convertEffectiveValue(const ::com::sun::star::uno::Any& rValue)
1028 : {
1029 0 : ::com::sun::star::uno::Any aReturn;
1030 :
1031 0 : FormattedField* pField = GetFormattedField();
1032 0 : if (!pField)
1033 0 : return aReturn;
1034 :
1035 0 : switch (rValue.getValueType().getTypeClass())
1036 : {
1037 : case ::com::sun::star::uno::TypeClass_DOUBLE:
1038 0 : if (pField->TreatingAsNumber())
1039 : {
1040 0 : double d = 0.0;
1041 0 : rValue >>= d;
1042 0 : aReturn <<= d;
1043 : }
1044 : else
1045 : {
1046 0 : SvNumberFormatter* pFormatter = pField->GetFormatter();
1047 0 : if (!pFormatter)
1048 0 : pFormatter = pField->StandardFormatter();
1049 : // should never fail
1050 :
1051 : Color* pDum;
1052 0 : double d = 0.0;
1053 0 : rValue >>= d;
1054 0 : String sConverted;
1055 0 : pFormatter->GetOutputString(d, 0, sConverted, &pDum);
1056 0 : aReturn <<= ::rtl::OUString( sConverted );
1057 : }
1058 0 : break;
1059 : case ::com::sun::star::uno::TypeClass_STRING:
1060 : {
1061 0 : ::rtl::OUString aStr;
1062 0 : rValue >>= aStr;
1063 0 : String sValue = aStr;
1064 0 : if (pField->TreatingAsNumber())
1065 : {
1066 0 : SvNumberFormatter* pFormatter = pField->GetFormatter();
1067 0 : if (!pFormatter)
1068 0 : pFormatter = pField->StandardFormatter();
1069 :
1070 : double dVal;
1071 0 : sal_uInt32 nTestFormat(0);
1072 0 : if (!pFormatter->IsNumberFormat(sValue, nTestFormat, dVal))
1073 0 : aReturn.clear();
1074 0 : aReturn <<=dVal;
1075 : }
1076 : else
1077 0 : aReturn <<= aStr;
1078 : }
1079 0 : break;
1080 : default:
1081 0 : aReturn.clear();
1082 0 : break;
1083 : }
1084 0 : return aReturn;
1085 : }
1086 :
1087 : // --------------------------------------------------------------------------------------
1088 0 : void SVTXFormattedField::SetMinValue(const ::com::sun::star::uno::Any& rValue)
1089 : {
1090 0 : FormattedField* pField = GetFormattedField();
1091 0 : if (!pField)
1092 0 : return;
1093 :
1094 0 : switch (rValue.getValueType().getTypeClass())
1095 :
1096 : {
1097 : case ::com::sun::star::uno::TypeClass_DOUBLE:
1098 : {
1099 0 : double d = 0.0;
1100 0 : rValue >>= d;
1101 0 : pField->SetMinValue(d);
1102 : }
1103 0 : break;
1104 : default:
1105 : DBG_ASSERT(rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID, "SVTXFormattedField::SetMinValue : invalid argument (an exception will be thrown) !");
1106 0 : if ( rValue.getValueType().getTypeClass() != ::com::sun::star::uno::TypeClass_VOID )
1107 :
1108 : {
1109 0 : throw ::com::sun::star::lang::IllegalArgumentException();
1110 : }
1111 0 : pField->ClearMinValue();
1112 0 : break;
1113 : }
1114 : }
1115 :
1116 : // --------------------------------------------------------------------------------------
1117 0 : ::com::sun::star::uno::Any SVTXFormattedField::GetMinValue()
1118 : {
1119 0 : FormattedField* pField = GetFormattedField();
1120 0 : if (!pField || !pField->HasMinValue())
1121 0 : return ::com::sun::star::uno::Any();
1122 :
1123 0 : ::com::sun::star::uno::Any aReturn;
1124 0 : aReturn <<= pField->GetMinValue();
1125 0 : return aReturn;
1126 : }
1127 :
1128 : // --------------------------------------------------------------------------------------
1129 0 : void SVTXFormattedField::SetMaxValue(const ::com::sun::star::uno::Any& rValue)
1130 : {
1131 0 : FormattedField* pField = GetFormattedField();
1132 0 : if (!pField)
1133 0 : return;
1134 :
1135 0 : switch (rValue.getValueType().getTypeClass())
1136 :
1137 : {
1138 : case ::com::sun::star::uno::TypeClass_DOUBLE:
1139 : {
1140 0 : double d = 0.0;
1141 0 : rValue >>= d;
1142 0 : pField->SetMaxValue(d);
1143 : }
1144 0 : break;
1145 : default:
1146 0 : if (rValue.getValueType().getTypeClass() != ::com::sun::star::uno::TypeClass_VOID)
1147 :
1148 : {
1149 0 : throw ::com::sun::star::lang::IllegalArgumentException();
1150 : }
1151 0 : pField->ClearMaxValue();
1152 0 : break;
1153 : }
1154 : }
1155 :
1156 : // --------------------------------------------------------------------------------------
1157 0 : ::com::sun::star::uno::Any SVTXFormattedField::GetMaxValue()
1158 : {
1159 0 : FormattedField* pField = GetFormattedField();
1160 0 : if (!pField || !pField->HasMaxValue())
1161 0 : return ::com::sun::star::uno::Any();
1162 :
1163 0 : ::com::sun::star::uno::Any aReturn;
1164 0 : aReturn <<= pField->GetMaxValue();
1165 0 : return aReturn;
1166 : }
1167 :
1168 : // --------------------------------------------------------------------------------------
1169 0 : void SVTXFormattedField::SetDefaultValue(const ::com::sun::star::uno::Any& rValue)
1170 : {
1171 0 : FormattedField* pField = GetFormattedField();
1172 0 : if (!pField)
1173 0 : return;
1174 :
1175 0 : ::com::sun::star::uno::Any aConverted = convertEffectiveValue(rValue);
1176 :
1177 0 : switch (aConverted.getValueType().getTypeClass())
1178 :
1179 : {
1180 : case ::com::sun::star::uno::TypeClass_DOUBLE:
1181 : {
1182 0 : double d = 0.0;
1183 0 : aConverted >>= d;
1184 0 : pField->SetDefaultValue(d);
1185 : }
1186 0 : break;
1187 : case ::com::sun::star::uno::TypeClass_STRING:
1188 : {
1189 0 : ::rtl::OUString aStr;
1190 0 : aConverted >>= aStr;
1191 0 : pField->SetDefaultText( aStr );
1192 : }
1193 0 : break;
1194 : default:
1195 0 : pField->EnableEmptyField(sal_True);
1196 : // nur noch void erlaubt
1197 0 : break;
1198 0 : }
1199 : }
1200 :
1201 : // --------------------------------------------------------------------------------------
1202 0 : ::com::sun::star::uno::Any SVTXFormattedField::GetDefaultValue()
1203 : {
1204 0 : FormattedField* pField = GetFormattedField();
1205 0 : if (!pField || pField->IsEmptyFieldEnabled())
1206 0 : return ::com::sun::star::uno::Any();
1207 :
1208 0 : ::com::sun::star::uno::Any aReturn;
1209 0 : if (pField->TreatingAsNumber())
1210 0 : aReturn <<= pField->GetDefaultValue();
1211 : else
1212 0 : aReturn <<= ::rtl::OUString( pField->GetDefaultText() );
1213 0 : return aReturn;
1214 : }
1215 :
1216 : // --------------------------------------------------------------------------------------
1217 0 : sal_Bool SVTXFormattedField::GetTreatAsNumber()
1218 : {
1219 0 : FormattedField* pField = GetFormattedField();
1220 0 : if (pField)
1221 0 : return pField->TreatingAsNumber();
1222 :
1223 0 : return sal_True;
1224 : }
1225 :
1226 : // --------------------------------------------------------------------------------------
1227 0 : void SVTXFormattedField::SetTreatAsNumber(sal_Bool bSet)
1228 : {
1229 0 : FormattedField* pField = GetFormattedField();
1230 0 : if (pField)
1231 0 : pField->TreatAsNumber(bSet);
1232 0 : }
1233 :
1234 : // --------------------------------------------------------------------------------------
1235 0 : ::com::sun::star::uno::Any SVTXFormattedField::GetValue()
1236 : {
1237 0 : FormattedField* pField = GetFormattedField();
1238 0 : if (!pField)
1239 0 : return ::com::sun::star::uno::Any();
1240 :
1241 0 : ::com::sun::star::uno::Any aReturn;
1242 0 : if (!pField->TreatingAsNumber())
1243 : {
1244 0 : ::rtl::OUString sText = pField->GetTextValue();
1245 0 : aReturn <<= sText;
1246 : }
1247 : else
1248 : {
1249 0 : if (pField->GetText().Len()) // empty wird erst mal standardmaessig als void nach draussen gereicht
1250 0 : aReturn <<= pField->GetValue();
1251 : }
1252 :
1253 0 : return aReturn;
1254 : }
1255 :
1256 : // --------------------------------------------------------------------------------------
1257 0 : void SVTXFormattedField::SetValue(const ::com::sun::star::uno::Any& rValue)
1258 : {
1259 0 : FormattedField* pField = GetFormattedField();
1260 0 : if (!pField)
1261 0 : return;
1262 :
1263 0 : if (!rValue.hasValue())
1264 : {
1265 0 : pField->SetText(String());
1266 : }
1267 : else
1268 : {
1269 0 : if (rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_DOUBLE )
1270 : {
1271 0 : double d = 0.0;
1272 0 : rValue >>= d;
1273 0 : pField->SetValue(d);
1274 : }
1275 : else
1276 : {
1277 : DBG_ASSERT(rValue.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_STRING, "SVTXFormattedField::SetValue : invalid argument !");
1278 :
1279 0 : ::rtl::OUString sText;
1280 0 : rValue >>= sText;
1281 0 : String aStr( sText );
1282 0 : if (!pField->TreatingAsNumber())
1283 0 : pField->SetTextFormatted(aStr);
1284 : else
1285 0 : pField->SetTextValue(aStr);
1286 : }
1287 : }
1288 : // NotifyTextListeners();
1289 : }
1290 :
1291 : // --------------------------------------------------------------------------------------
1292 0 : ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > SVTXFormattedField::getFormatsSupplier(void) const
1293 : {
1294 0 : return ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > ((::com::sun::star::util::XNumberFormatsSupplier*)m_pCurrentSupplier);
1295 : }
1296 :
1297 : // --------------------------------------------------------------------------------------
1298 0 : void SVTXFormattedField::setFormatsSupplier(const ::com::sun::star::uno::Reference< ::com::sun::star::util::XNumberFormatsSupplier > & xSupplier)
1299 : {
1300 0 : FormattedField* pField = GetFormattedField();
1301 :
1302 0 : SvNumberFormatsSupplierObj* pNew = NULL;
1303 0 : if (!xSupplier.is())
1304 : {
1305 0 : if (pField)
1306 : {
1307 0 : pNew = new SvNumberFormatsSupplierObj(pField->StandardFormatter());
1308 0 : bIsStandardSupplier = sal_True;
1309 : }
1310 : }
1311 : else
1312 : {
1313 0 : pNew = SvNumberFormatsSupplierObj::getImplementation(xSupplier);
1314 0 : bIsStandardSupplier = sal_False;
1315 : }
1316 :
1317 0 : if (!pNew)
1318 0 : return; // TODO : wie das behandeln ?
1319 :
1320 0 : if (m_pCurrentSupplier)
1321 0 : m_pCurrentSupplier->release();
1322 0 : m_pCurrentSupplier = pNew;
1323 0 : m_pCurrentSupplier->acquire();
1324 0 : if (pField)
1325 : {
1326 : // den aktuellen Value mit hinueberretten
1327 0 : ::com::sun::star::uno::Any aCurrent = GetValue();
1328 0 : pField->SetFormatter(m_pCurrentSupplier->GetNumberFormatter(), sal_False);
1329 0 : if (nKeyToSetDelayed != -1)
1330 : {
1331 0 : pField->SetFormatKey(nKeyToSetDelayed);
1332 0 : nKeyToSetDelayed = -1;
1333 : }
1334 0 : SetValue(aCurrent);
1335 0 : NotifyTextListeners();
1336 : }
1337 : }
1338 :
1339 : // --------------------------------------------------------------------------------------
1340 0 : sal_Int32 SVTXFormattedField::getFormatKey(void) const
1341 : {
1342 0 : FormattedField* pField = GetFormattedField();
1343 0 : return pField ? pField->GetFormatKey() : 0;
1344 : }
1345 :
1346 : // --------------------------------------------------------------------------------------
1347 0 : void SVTXFormattedField::setFormatKey(sal_Int32 nKey)
1348 : {
1349 0 : FormattedField* pField = GetFormattedField();
1350 0 : if (pField)
1351 : {
1352 0 : if (pField->GetFormatter())
1353 0 : pField->SetFormatKey(nKey);
1354 : else
1355 : { // Wahrscheinlich bin ich gerade in einem Block, in dem erst der Key und dann der Formatter gesetzt
1356 : // wird, das passiert initial mit ziemlicher Sicherheit, da die Properties in alphabetischer Reihenfolge
1357 : // gesetzt werden, und der FormatsSupplier nun mal vor dem FormatKey kommt
1358 0 : nKeyToSetDelayed = nKey;
1359 : }
1360 0 : NotifyTextListeners();
1361 : }
1362 0 : }
1363 :
1364 : // --------------------------------------------------------------------------------------
1365 0 : void SVTXFormattedField::NotifyTextListeners()
1366 : {
1367 0 : if ( GetTextListeners().getLength() )
1368 : {
1369 0 : ::com::sun::star::awt::TextEvent aEvent;
1370 0 : aEvent.Source = (::cppu::OWeakObject*)this;
1371 0 : GetTextListeners().textChanged( aEvent );
1372 : }
1373 0 : }
1374 :
1375 0 : void SVTXFormattedField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1376 : {
1377 : PushPropertyIds( rIds,
1378 : // FIXME: elide duplication ?
1379 : BASEPROPERTY_EFFECTIVE_MIN,
1380 : BASEPROPERTY_VALUEMIN_DOUBLE,
1381 : BASEPROPERTY_EFFECTIVE_MAX,
1382 : BASEPROPERTY_VALUEMAX_DOUBLE,
1383 : BASEPROPERTY_EFFECTIVE_DEFAULT,
1384 : BASEPROPERTY_TREATASNUMBER,
1385 : BASEPROPERTY_EFFECTIVE_VALUE,
1386 : BASEPROPERTY_VALUE_DOUBLE,
1387 : BASEPROPERTY_VALUESTEP_DOUBLE,
1388 : BASEPROPERTY_DECIMALACCURACY,
1389 : BASEPROPERTY_FORMATSSUPPLIER,
1390 : BASEPROPERTY_NUMSHOWTHOUSANDSEP,
1391 : BASEPROPERTY_FORMATKEY,
1392 : BASEPROPERTY_TREATASNUMBER,
1393 : BASEPROPERTY_ENFORCE_FORMAT,
1394 0 : 0);
1395 0 : VCLXWindow::ImplGetPropertyIds( rIds, true );
1396 0 : VCLXSpinField::ImplGetPropertyIds( rIds );
1397 0 : }
1398 :
1399 :
1400 : // ----------------------------------------------------
1401 : // class SVTXRoadmap
1402 : // ----------------------------------------------------
1403 :
1404 : using namespace svt;
1405 :
1406 : // --------------------------------------------------------------------------------------
1407 0 : SVTXRoadmap::SVTXRoadmap() : maItemListeners( *this )
1408 : {
1409 0 : }
1410 :
1411 : // --------------------------------------------------------------------------------------
1412 0 : SVTXRoadmap::~SVTXRoadmap()
1413 : {
1414 0 : }
1415 :
1416 0 : void SVTXRoadmap::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1417 : {
1418 0 : switch ( rVclWindowEvent.GetId() )
1419 : {
1420 : case VCLEVENT_ROADMAP_ITEMSELECTED:
1421 : {
1422 0 : SolarMutexGuard aGuard;
1423 0 : ::svt::ORoadmap* pField = GetRoadmap();
1424 0 : if ( pField )
1425 : {
1426 0 : sal_Int16 CurItemID = pField->GetCurrentRoadmapItemID();
1427 0 : ::com::sun::star::awt::ItemEvent aEvent;
1428 0 : aEvent.Selected = CurItemID;
1429 0 : aEvent.Highlighted = CurItemID;
1430 0 : aEvent.ItemId = CurItemID;
1431 0 : maItemListeners.itemStateChanged( aEvent );
1432 0 : }
1433 : }
1434 0 : break;
1435 : default:
1436 0 : SVTXRoadmap_Base::ProcessWindowEvent( rVclWindowEvent );
1437 0 : break;
1438 : }
1439 0 : }
1440 :
1441 :
1442 0 : void SVTXRoadmap::propertyChange( const ::com::sun::star::beans::PropertyChangeEvent& evt ) throw (::com::sun::star::uno::RuntimeException)
1443 : {
1444 0 : SolarMutexGuard aGuard;
1445 0 : ::svt::ORoadmap* pField = GetRoadmap();
1446 0 : if ( pField )
1447 : {
1448 0 : ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xRoadmapItem;
1449 0 : xRoadmapItem = evt.Source;
1450 0 : sal_Int32 nID = 0;
1451 0 : ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > xPropertySet( xRoadmapItem, ::com::sun::star::uno::UNO_QUERY );
1452 0 : ::com::sun::star::uno::Any aValue = xPropertySet->getPropertyValue(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ID" )));
1453 0 : aValue >>= nID;
1454 :
1455 0 : ::com::sun::star::uno::Any rVal = evt.NewValue;
1456 0 : evt.NewValue >>= rVal;
1457 0 : ::rtl::OUString sPropertyName = evt.PropertyName;
1458 0 : if ( sPropertyName == "Enabled" )
1459 : {
1460 0 : sal_Bool bEnable = false;
1461 0 : evt.NewValue >>= bEnable;
1462 0 : pField->EnableRoadmapItem( (RoadmapTypes::ItemId)nID , bEnable );
1463 : }
1464 0 : else if ( sPropertyName == "Label" )
1465 : {
1466 0 : ::rtl::OUString sLabel;
1467 0 : evt.NewValue >>= sLabel;
1468 0 : pField->ChangeRoadmapItemLabel( (RoadmapTypes::ItemId)nID , sLabel );
1469 : }
1470 0 : else if ( sPropertyName == "ID" )
1471 : {
1472 0 : sal_Int32 nNewID = 0;
1473 0 : evt.NewValue >>= nNewID;
1474 0 : evt.OldValue >>= nID;
1475 0 : pField->ChangeRoadmapItemID( (RoadmapTypes::ItemId)nID, (RoadmapTypes::ItemId)nNewID );
1476 0 : }
1477 : // else
1478 : // Todo: handle Interactive appropriately
1479 0 : }
1480 0 : }
1481 :
1482 :
1483 0 : void SVTXRoadmap::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener >& l ) throw (::com::sun::star::uno::RuntimeException)
1484 : {
1485 0 : maItemListeners.addInterface( l );
1486 0 : }
1487 :
1488 0 : void SVTXRoadmap::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener >& l ) throw (::com::sun::star::uno::RuntimeException)
1489 : {
1490 0 : maItemListeners.removeInterface( l );
1491 0 : }
1492 :
1493 0 : RMItemData SVTXRoadmap::GetRMItemData( const ::com::sun::star::container::ContainerEvent& _rEvent )
1494 : {
1495 0 : RMItemData aCurRMItemData;
1496 0 : ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xRoadmapItem;
1497 0 : _rEvent.Element >>= xRoadmapItem;
1498 0 : ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > xPropertySet( xRoadmapItem, ::com::sun::star::uno::UNO_QUERY );
1499 0 : if ( xPropertySet.is() )
1500 : {
1501 0 : ::com::sun::star::uno::Any aValue = xPropertySet->getPropertyValue(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Label" )));
1502 0 : aValue >>= aCurRMItemData.Label;
1503 0 : aValue = xPropertySet->getPropertyValue(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ID" )));
1504 0 : aValue >>= aCurRMItemData.n_ID;
1505 0 : aValue = xPropertySet->getPropertyValue(::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Enabled" )));
1506 0 : aValue >>= aCurRMItemData.b_Enabled;
1507 : }
1508 0 : return aCurRMItemData;
1509 : }
1510 :
1511 0 : void SVTXRoadmap::elementInserted( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException)
1512 : {
1513 0 : SolarMutexGuard aGuard;
1514 0 : ::svt::ORoadmap* pField = GetRoadmap();
1515 0 : if ( pField )
1516 : {
1517 0 : RMItemData CurItemData = GetRMItemData( _rEvent );
1518 0 : sal_Int32 InsertIndex = 0;
1519 0 : _rEvent.Accessor >>= InsertIndex;
1520 0 : pField->InsertRoadmapItem( InsertIndex, CurItemData.Label, (RoadmapTypes::ItemId)CurItemData.n_ID, CurItemData.b_Enabled );
1521 0 : }
1522 0 : }
1523 :
1524 0 : void SVTXRoadmap::elementRemoved( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException)
1525 : {
1526 0 : SolarMutexGuard aGuard;
1527 0 : ::svt::ORoadmap* pField = GetRoadmap();
1528 0 : if ( pField )
1529 : {
1530 0 : sal_Int32 DelIndex = 0;
1531 0 : _rEvent.Accessor >>= DelIndex;
1532 0 : pField->DeleteRoadmapItem(DelIndex);
1533 0 : }
1534 0 : }
1535 :
1536 0 : void SVTXRoadmap::elementReplaced( const ::com::sun::star::container::ContainerEvent& _rEvent )throw(::com::sun::star::uno::RuntimeException)
1537 : {
1538 0 : SolarMutexGuard aGuard;
1539 0 : ::svt::ORoadmap* pField = GetRoadmap();
1540 0 : if ( pField )
1541 : {
1542 0 : RMItemData CurItemData = GetRMItemData( _rEvent );
1543 0 : sal_Int32 ReplaceIndex = 0;
1544 0 : _rEvent.Accessor >>= ReplaceIndex;
1545 0 : pField->ReplaceRoadmapItem( ReplaceIndex, CurItemData.Label, (RoadmapTypes::ItemId)CurItemData.n_ID, CurItemData.b_Enabled );
1546 0 : }
1547 0 : }
1548 :
1549 :
1550 :
1551 : // --------------------------------------------------------------------------------------
1552 0 : void SVTXRoadmap::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
1553 : {
1554 0 : SolarMutexGuard aGuard;
1555 :
1556 0 : ::svt::ORoadmap* pField = GetRoadmap();
1557 0 : if ( pField )
1558 : {
1559 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1560 0 : switch (nPropType)
1561 : {
1562 : case BASEPROPERTY_COMPLETE:
1563 : {
1564 0 : sal_Bool b = false;
1565 0 : Value >>= b;
1566 0 : pField->SetRoadmapComplete( b);
1567 : }
1568 0 : break;
1569 :
1570 : case BASEPROPERTY_ACTIVATED:
1571 : {
1572 0 : sal_Bool b = false;
1573 0 : Value >>= b;
1574 0 : pField->SetRoadmapInteractive( b);
1575 : }
1576 0 : break;
1577 :
1578 : case BASEPROPERTY_CURRENTITEMID:
1579 : {
1580 0 : sal_Int32 nId = 0;
1581 0 : Value >>= nId;
1582 0 : pField->SelectRoadmapItemByID( (RoadmapTypes::ItemId)nId );
1583 : }
1584 0 : break;
1585 :
1586 : case BASEPROPERTY_TEXT:
1587 : {
1588 0 : ::rtl::OUString aStr;
1589 0 : Value >>= aStr;
1590 0 : pField->SetText( aStr );
1591 0 : pField->Invalidate();
1592 : }
1593 0 : break;
1594 :
1595 : default:
1596 0 : SVTXRoadmap_Base::setProperty( PropertyName, Value );
1597 0 : break;
1598 : }
1599 :
1600 : }
1601 : else
1602 0 : SVTXRoadmap_Base::setProperty( PropertyName, Value );
1603 0 : }
1604 :
1605 :
1606 : // --------------------------------------------------------------------------------------
1607 0 : ::com::sun::star::uno::Any SVTXRoadmap::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
1608 : {
1609 0 : SolarMutexGuard aGuard;
1610 :
1611 0 : ::com::sun::star::uno::Any aReturn;
1612 :
1613 0 : ::svt::ORoadmap* pField = GetRoadmap();
1614 0 : if ( pField )
1615 : {
1616 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1617 0 : switch (nPropType)
1618 : {
1619 : case BASEPROPERTY_COMPLETE:
1620 0 : aReturn <<= pField->IsRoadmapComplete();
1621 0 : break;
1622 : case BASEPROPERTY_ACTIVATED:
1623 0 : aReturn <<= pField->IsRoadmapInteractive();
1624 0 : break;
1625 : case BASEPROPERTY_CURRENTITEMID:
1626 0 : aReturn <<= pField->GetCurrentRoadmapItemID();
1627 0 : break;
1628 : default:
1629 0 : aReturn = SVTXRoadmap_Base::getProperty(PropertyName);
1630 0 : break;
1631 : }
1632 : }
1633 0 : return aReturn;
1634 : }
1635 :
1636 0 : void SVTXRoadmap::ImplSetNewImage()
1637 : {
1638 : OSL_PRECOND( GetWindow(), "SVTXRoadmap::ImplSetNewImage: window is required to be not-NULL!" );
1639 0 : ::svt::ORoadmap* pButton = static_cast< ::svt::ORoadmap* >( GetWindow() );
1640 0 : pButton->SetRoadmapBitmap( GetImage().GetBitmapEx() );
1641 0 : }
1642 :
1643 0 : void SVTXRoadmap::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1644 : {
1645 : PushPropertyIds( rIds,
1646 : BASEPROPERTY_COMPLETE,
1647 : BASEPROPERTY_ACTIVATED,
1648 : BASEPROPERTY_CURRENTITEMID,
1649 : BASEPROPERTY_TEXT,
1650 0 : 0);
1651 0 : VCLXWindow::ImplGetPropertyIds( rIds, true );
1652 0 : VCLXGraphicControl::ImplGetPropertyIds( rIds );
1653 0 : }
1654 :
1655 : // ----------------------------------------------------
1656 : // class SVTXNumericField
1657 : // ----------------------------------------------------
1658 0 : SVTXNumericField::SVTXNumericField()
1659 : {
1660 0 : }
1661 :
1662 0 : SVTXNumericField::~SVTXNumericField()
1663 : {
1664 0 : }
1665 :
1666 0 : ::com::sun::star::uno::Any SVTXNumericField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
1667 : {
1668 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1669 : (static_cast< ::com::sun::star::awt::XNumericField* >(this)),
1670 0 : (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
1671 0 : return (aRet.hasValue() ? aRet : SVTXFormattedField::queryInterface( rType ));
1672 : }
1673 :
1674 : // ::com::sun::star::lang::XTypeProvider
1675 0 : IMPL_XTYPEPROVIDER_START( SVTXNumericField )
1676 0 : getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XNumericField>* ) NULL ),
1677 : SVTXFormattedField::getTypes()
1678 0 : IMPL_XTYPEPROVIDER_END
1679 :
1680 :
1681 0 : void SVTXNumericField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException)
1682 : {
1683 0 : SolarMutexGuard aGuard;
1684 :
1685 0 : FormattedField* pField = GetFormattedField();
1686 0 : if ( pField )
1687 0 : pField->SetValue( Value );
1688 0 : }
1689 :
1690 0 : double SVTXNumericField::getValue() throw(::com::sun::star::uno::RuntimeException)
1691 : {
1692 0 : SolarMutexGuard aGuard;
1693 :
1694 0 : FormattedField* pField = GetFormattedField();
1695 0 : return pField ? pField->GetValue() : 0;
1696 : }
1697 :
1698 0 : void SVTXNumericField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException)
1699 : {
1700 0 : SolarMutexGuard aGuard;
1701 :
1702 0 : FormattedField* pField = GetFormattedField();
1703 0 : if ( pField )
1704 0 : pField->SetMinValue( Value );
1705 0 : }
1706 :
1707 0 : double SVTXNumericField::getMin() throw(::com::sun::star::uno::RuntimeException)
1708 : {
1709 0 : SolarMutexGuard aGuard;
1710 :
1711 0 : FormattedField* pField = GetFormattedField();
1712 0 : return pField ? pField->GetMinValue() : 0;
1713 : }
1714 :
1715 0 : void SVTXNumericField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException)
1716 : {
1717 0 : SolarMutexGuard aGuard;
1718 :
1719 0 : FormattedField* pField = GetFormattedField();
1720 0 : if ( pField )
1721 0 : pField->SetMaxValue( Value );
1722 0 : }
1723 :
1724 0 : double SVTXNumericField::getMax() throw(::com::sun::star::uno::RuntimeException)
1725 : {
1726 0 : SolarMutexGuard aGuard;
1727 :
1728 0 : FormattedField* pField = GetFormattedField();
1729 0 : return pField ? pField->GetMaxValue() : 0;
1730 : }
1731 :
1732 0 : void SVTXNumericField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException)
1733 : {
1734 0 : SolarMutexGuard aGuard;
1735 :
1736 0 : FormattedField* pField = GetFormattedField();
1737 0 : if ( pField )
1738 0 : pField->SetSpinFirst( Value );
1739 0 : }
1740 :
1741 0 : double SVTXNumericField::getFirst() throw(::com::sun::star::uno::RuntimeException)
1742 : {
1743 0 : SolarMutexGuard aGuard;
1744 :
1745 0 : FormattedField* pField = GetFormattedField();
1746 0 : return pField ? pField->GetSpinFirst() : 0;
1747 : }
1748 :
1749 0 : void SVTXNumericField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException)
1750 : {
1751 0 : SolarMutexGuard aGuard;
1752 :
1753 0 : FormattedField* pField = GetFormattedField();
1754 0 : if ( pField )
1755 0 : pField->SetSpinLast( Value );
1756 0 : }
1757 :
1758 0 : double SVTXNumericField::getLast() throw(::com::sun::star::uno::RuntimeException)
1759 : {
1760 0 : SolarMutexGuard aGuard;
1761 :
1762 0 : FormattedField* pField = GetFormattedField();
1763 0 : return pField ? pField->GetSpinLast() : 0;
1764 : }
1765 :
1766 0 : void SVTXNumericField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException)
1767 : {
1768 0 : SolarMutexGuard aGuard;
1769 :
1770 0 : FormattedField* pField = GetFormattedField();
1771 0 : if ( pField )
1772 0 : pField->SetSpinSize( Value );
1773 0 : }
1774 :
1775 0 : double SVTXNumericField::getSpinSize() throw(::com::sun::star::uno::RuntimeException)
1776 : {
1777 0 : SolarMutexGuard aGuard;
1778 :
1779 0 : FormattedField* pField = GetFormattedField();
1780 0 : return pField ? pField->GetSpinSize() : 0;
1781 : }
1782 :
1783 0 : void SVTXNumericField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException)
1784 : {
1785 0 : SolarMutexGuard aGuard;
1786 :
1787 0 : FormattedField* pField = GetFormattedField();
1788 0 : if ( pField )
1789 0 : pField->SetDecimalDigits( Value );
1790 0 : }
1791 :
1792 0 : sal_Int16 SVTXNumericField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException)
1793 : {
1794 0 : SolarMutexGuard aGuard;
1795 :
1796 0 : FormattedField* pField = GetFormattedField();
1797 0 : return pField ? pField->GetDecimalDigits() : 0;
1798 : }
1799 :
1800 0 : void SVTXNumericField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
1801 : {
1802 0 : SolarMutexGuard aGuard;
1803 :
1804 0 : FormattedField* pField = GetFormattedField();
1805 0 : if ( pField )
1806 0 : pField->SetStrictFormat( bStrict );
1807 0 : }
1808 :
1809 0 : sal_Bool SVTXNumericField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
1810 : {
1811 0 : SolarMutexGuard aGuard;
1812 :
1813 0 : FormattedField* pField = GetFormattedField();
1814 0 : return pField ? pField->IsStrictFormat() : sal_False;
1815 : }
1816 :
1817 0 : void SVTXNumericField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1818 : {
1819 0 : SVTXFormattedField::ImplGetPropertyIds( rIds );
1820 0 : }
1821 :
1822 : // ----------------------------------------------------
1823 : // class SVTXCurrencyField
1824 : // ----------------------------------------------------
1825 0 : SVTXCurrencyField::SVTXCurrencyField()
1826 : {
1827 0 : }
1828 :
1829 0 : SVTXCurrencyField::~SVTXCurrencyField()
1830 : {
1831 0 : }
1832 :
1833 0 : ::com::sun::star::uno::Any SVTXCurrencyField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
1834 : {
1835 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1836 : (static_cast< ::com::sun::star::awt::XCurrencyField* >(this)),
1837 0 : (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
1838 0 : return (aRet.hasValue() ? aRet : SVTXFormattedField::queryInterface( rType ));
1839 : }
1840 :
1841 : // ::com::sun::star::lang::XTypeProvider
1842 0 : IMPL_XTYPEPROVIDER_START( SVTXCurrencyField )
1843 0 : getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XCurrencyField>* ) NULL ),
1844 : SVTXFormattedField::getTypes()
1845 0 : IMPL_XTYPEPROVIDER_END
1846 :
1847 0 : void SVTXCurrencyField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException)
1848 : {
1849 0 : SolarMutexGuard aGuard;
1850 :
1851 0 : FormattedField* pField = GetFormattedField();
1852 0 : if ( pField )
1853 0 : pField->SetValue( Value );
1854 0 : }
1855 :
1856 0 : double SVTXCurrencyField::getValue() throw(::com::sun::star::uno::RuntimeException)
1857 : {
1858 0 : SolarMutexGuard aGuard;
1859 :
1860 0 : FormattedField* pField = GetFormattedField();
1861 0 : return pField ? pField->GetValue() : 0;
1862 : }
1863 :
1864 0 : void SVTXCurrencyField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException)
1865 : {
1866 0 : SolarMutexGuard aGuard;
1867 :
1868 0 : FormattedField* pField = GetFormattedField();
1869 0 : if ( pField )
1870 0 : pField->SetMinValue( Value );
1871 0 : }
1872 :
1873 0 : double SVTXCurrencyField::getMin() throw(::com::sun::star::uno::RuntimeException)
1874 : {
1875 0 : SolarMutexGuard aGuard;
1876 :
1877 0 : FormattedField* pField = GetFormattedField();
1878 0 : return pField ? pField->GetMinValue() : 0;
1879 : }
1880 :
1881 0 : void SVTXCurrencyField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException)
1882 : {
1883 0 : SolarMutexGuard aGuard;
1884 :
1885 0 : FormattedField* pField = GetFormattedField();
1886 0 : if ( pField )
1887 0 : pField->SetMaxValue( Value );
1888 0 : }
1889 :
1890 0 : double SVTXCurrencyField::getMax() throw(::com::sun::star::uno::RuntimeException)
1891 : {
1892 0 : SolarMutexGuard aGuard;
1893 :
1894 0 : FormattedField* pField = GetFormattedField();
1895 0 : return pField ? pField->GetMaxValue() : 0;
1896 : }
1897 :
1898 0 : void SVTXCurrencyField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException)
1899 : {
1900 0 : SolarMutexGuard aGuard;
1901 :
1902 0 : FormattedField* pField = GetFormattedField();
1903 0 : if ( pField )
1904 0 : pField->SetSpinFirst( Value );
1905 0 : }
1906 :
1907 0 : double SVTXCurrencyField::getFirst() throw(::com::sun::star::uno::RuntimeException)
1908 : {
1909 0 : SolarMutexGuard aGuard;
1910 :
1911 0 : FormattedField* pField = GetFormattedField();
1912 0 : return pField ? pField->GetSpinFirst() : 0;
1913 : }
1914 :
1915 0 : void SVTXCurrencyField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException)
1916 : {
1917 0 : SolarMutexGuard aGuard;
1918 :
1919 0 : FormattedField* pField = GetFormattedField();
1920 0 : if ( pField )
1921 0 : pField->SetSpinLast( Value );
1922 0 : }
1923 :
1924 0 : double SVTXCurrencyField::getLast() throw(::com::sun::star::uno::RuntimeException)
1925 : {
1926 0 : SolarMutexGuard aGuard;
1927 :
1928 0 : FormattedField* pField = GetFormattedField();
1929 0 : return pField ? pField->GetSpinLast() : 0;
1930 : }
1931 :
1932 0 : void SVTXCurrencyField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException)
1933 : {
1934 0 : SolarMutexGuard aGuard;
1935 :
1936 0 : FormattedField* pField = GetFormattedField();
1937 0 : if ( pField )
1938 0 : pField->SetSpinSize( Value );
1939 0 : }
1940 :
1941 0 : double SVTXCurrencyField::getSpinSize() throw(::com::sun::star::uno::RuntimeException)
1942 : {
1943 0 : SolarMutexGuard aGuard;
1944 :
1945 0 : FormattedField* pField = GetFormattedField();
1946 0 : return pField ? pField->GetSpinSize() : 0;
1947 : }
1948 :
1949 0 : void SVTXCurrencyField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException)
1950 : {
1951 0 : SolarMutexGuard aGuard;
1952 :
1953 0 : FormattedField* pField = GetFormattedField();
1954 0 : if ( pField )
1955 0 : pField->SetDecimalDigits( Value );
1956 0 : }
1957 :
1958 0 : sal_Int16 SVTXCurrencyField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException)
1959 : {
1960 0 : SolarMutexGuard aGuard;
1961 :
1962 0 : FormattedField* pField = GetFormattedField();
1963 0 : return pField ? pField->GetDecimalDigits() : 0;
1964 : }
1965 :
1966 0 : void SVTXCurrencyField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException)
1967 : {
1968 0 : SolarMutexGuard aGuard;
1969 :
1970 0 : FormattedField* pField = GetFormattedField();
1971 0 : if ( pField )
1972 0 : pField->SetStrictFormat( bStrict );
1973 0 : }
1974 :
1975 0 : sal_Bool SVTXCurrencyField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException)
1976 : {
1977 0 : SolarMutexGuard aGuard;
1978 :
1979 0 : FormattedField* pField = GetFormattedField();
1980 0 : return pField ? pField->IsStrictFormat() : sal_False;
1981 : }
1982 :
1983 0 : void SVTXCurrencyField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
1984 : {
1985 0 : SolarMutexGuard aGuard;
1986 :
1987 0 : ::com::sun::star::uno::Any aReturn;
1988 :
1989 0 : DoubleCurrencyField* pField = (DoubleCurrencyField*)GetFormattedField();
1990 0 : if ( pField )
1991 : {
1992 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1993 0 : switch (nPropType)
1994 : {
1995 : case BASEPROPERTY_CURRENCYSYMBOL:
1996 : {
1997 0 : ::rtl::OUString aStr;
1998 0 : Value >>= aStr;
1999 0 : pField->setCurrencySymbol( aStr );
2000 : }
2001 0 : break;
2002 : case BASEPROPERTY_CURSYM_POSITION:
2003 : {
2004 0 : sal_Bool b = false;
2005 0 : Value >>= b;
2006 0 : pField->setPrependCurrSym(b);
2007 : }
2008 0 : break;
2009 :
2010 : default:
2011 0 : SVTXFormattedField::setProperty(PropertyName, Value);
2012 : }
2013 : }
2014 : else
2015 0 : SVTXFormattedField::setProperty(PropertyName, Value);
2016 0 : }
2017 :
2018 0 : ::com::sun::star::uno::Any SVTXCurrencyField::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
2019 : {
2020 0 : SolarMutexGuard aGuard;
2021 :
2022 0 : ::com::sun::star::uno::Any aReturn;
2023 :
2024 0 : DoubleCurrencyField* pField = (DoubleCurrencyField*)GetFormattedField();
2025 0 : if ( pField )
2026 : {
2027 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
2028 0 : switch (nPropType)
2029 : {
2030 : case BASEPROPERTY_CURRENCYSYMBOL:
2031 : {
2032 0 : aReturn <<= ::rtl::OUString( pField->getCurrencySymbol() );
2033 : }
2034 0 : break;
2035 : case BASEPROPERTY_CURSYM_POSITION:
2036 : {
2037 0 : aReturn <<= pField->getPrependCurrSym();
2038 : }
2039 0 : break;
2040 : default:
2041 0 : return SVTXFormattedField::getProperty(PropertyName);
2042 : }
2043 : }
2044 0 : return SVTXFormattedField::getProperty(PropertyName);
2045 : }
2046 :
2047 0 : void SVTXCurrencyField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2048 : {
2049 : PushPropertyIds( rIds,
2050 : BASEPROPERTY_CURRENCYSYMBOL,
2051 : BASEPROPERTY_CURSYM_POSITION,
2052 0 : 0);
2053 0 : SVTXFormattedField::ImplGetPropertyIds( rIds );
2054 0 : }
2055 :
2056 :
2057 : // ----------------------------------------------------
2058 : // class VCLXProgressBar
2059 : // ----------------------------------------------------
2060 :
2061 0 : VCLXProgressBar::VCLXProgressBar()
2062 : :m_nValue(0)
2063 : ,m_nValueMin(0)
2064 0 : ,m_nValueMax(100)
2065 : {
2066 0 : }
2067 :
2068 0 : VCLXProgressBar::~VCLXProgressBar()
2069 : {
2070 0 : }
2071 :
2072 0 : void VCLXProgressBar::ImplUpdateValue()
2073 : {
2074 0 : ProgressBar* pProgressBar = (ProgressBar*) GetWindow();
2075 0 : if ( pProgressBar )
2076 : {
2077 : sal_Int32 nVal;
2078 : sal_Int32 nValMin;
2079 : sal_Int32 nValMax;
2080 :
2081 : // check min and max
2082 0 : if (m_nValueMin < m_nValueMax)
2083 : {
2084 0 : nValMin = m_nValueMin;
2085 0 : nValMax = m_nValueMax;
2086 : }
2087 : else
2088 : {
2089 0 : nValMin = m_nValueMax;
2090 0 : nValMax = m_nValueMin;
2091 : }
2092 :
2093 : // check value
2094 0 : if (m_nValue < nValMin)
2095 : {
2096 0 : nVal = nValMin;
2097 : }
2098 0 : else if (m_nValue > nValMax)
2099 : {
2100 0 : nVal = nValMax;
2101 : }
2102 : else
2103 : {
2104 0 : nVal = m_nValue;
2105 : }
2106 :
2107 : // calculate percent
2108 : sal_Int32 nPercent;
2109 0 : if (nValMin != nValMax)
2110 : {
2111 0 : nPercent = 100 * (nVal - nValMin) / (nValMax - nValMin);
2112 : }
2113 : else
2114 : {
2115 0 : nPercent = 0;
2116 : }
2117 :
2118 : // set progressbar value
2119 0 : pProgressBar->SetValue( (sal_uInt16) nPercent );
2120 : }
2121 0 : }
2122 :
2123 : // ::com::sun::star::uno::XInterface
2124 0 : ::com::sun::star::uno::Any VCLXProgressBar::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException)
2125 : {
2126 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2127 : (static_cast< ::com::sun::star::awt::XProgressBar* >(this)),
2128 0 : (static_cast< ::com::sun::star::lang::XTypeProvider* >(this)) );
2129 0 : return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
2130 : }
2131 :
2132 : // ::com::sun::star::lang::XTypeProvider
2133 0 : IMPL_XTYPEPROVIDER_START( VCLXProgressBar )
2134 0 : getCppuType( ( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XProgressBar>* ) NULL ),
2135 : VCLXWindow::getTypes()
2136 0 : IMPL_XTYPEPROVIDER_END
2137 :
2138 : // ::com::sun::star::awt::XProgressBar
2139 0 : void VCLXProgressBar::setForegroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
2140 : {
2141 0 : SolarMutexGuard aGuard;
2142 :
2143 0 : Window* pWindow = GetWindow();
2144 0 : if ( pWindow )
2145 : {
2146 0 : Color aColor( nColor );
2147 0 : pWindow->SetControlForeground( aColor );
2148 0 : }
2149 0 : }
2150 :
2151 0 : void VCLXProgressBar::setBackgroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
2152 : {
2153 0 : SolarMutexGuard aGuard;
2154 :
2155 0 : Window* pWindow = GetWindow();
2156 0 : if ( pWindow )
2157 : {
2158 0 : Color aColor( nColor );
2159 0 : pWindow->SetBackground( aColor );
2160 0 : pWindow->SetControlBackground( aColor );
2161 0 : pWindow->Invalidate();
2162 0 : }
2163 0 : }
2164 :
2165 0 : void VCLXProgressBar::setValue( sal_Int32 nValue ) throw(::com::sun::star::uno::RuntimeException)
2166 : {
2167 0 : SolarMutexGuard aGuard;
2168 :
2169 0 : m_nValue = nValue;
2170 0 : ImplUpdateValue();
2171 0 : }
2172 :
2173 0 : void VCLXProgressBar::setRange( sal_Int32 nMin, sal_Int32 nMax ) throw(::com::sun::star::uno::RuntimeException )
2174 : {
2175 0 : SolarMutexGuard aGuard;
2176 :
2177 0 : if ( nMin < nMax )
2178 : {
2179 : // take correct min and max
2180 0 : m_nValueMin = nMin;
2181 0 : m_nValueMax = nMax;
2182 : }
2183 : else
2184 : {
2185 : // change min and max
2186 0 : m_nValueMin = nMax;
2187 0 : m_nValueMax = nMin;
2188 : }
2189 :
2190 0 : ImplUpdateValue();
2191 0 : }
2192 :
2193 0 : sal_Int32 VCLXProgressBar::getValue() throw(::com::sun::star::uno::RuntimeException)
2194 : {
2195 0 : SolarMutexGuard aGuard;
2196 :
2197 0 : return m_nValue;
2198 : }
2199 :
2200 : // ::com::sun::star::awt::VclWindowPeer
2201 0 : void VCLXProgressBar::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException)
2202 : {
2203 0 : SolarMutexGuard aGuard;
2204 :
2205 0 : ProgressBar* pProgressBar = (ProgressBar*)GetWindow();
2206 0 : if ( pProgressBar )
2207 : {
2208 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
2209 0 : switch ( nPropType )
2210 : {
2211 : case BASEPROPERTY_PROGRESSVALUE:
2212 : {
2213 0 : if ( Value >>= m_nValue )
2214 0 : ImplUpdateValue();
2215 : }
2216 0 : break;
2217 : case BASEPROPERTY_PROGRESSVALUE_MIN:
2218 : {
2219 0 : if ( Value >>= m_nValueMin )
2220 0 : ImplUpdateValue();
2221 : }
2222 0 : break;
2223 : case BASEPROPERTY_PROGRESSVALUE_MAX:
2224 : {
2225 0 : if ( Value >>= m_nValueMax )
2226 0 : ImplUpdateValue();
2227 : }
2228 0 : break;
2229 : case BASEPROPERTY_FILLCOLOR:
2230 : {
2231 0 : Window* pWindow = GetWindow();
2232 0 : if ( pWindow )
2233 : {
2234 0 : sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
2235 :
2236 0 : if ( bVoid )
2237 : {
2238 0 : pWindow->SetControlForeground();
2239 : }
2240 : else
2241 : {
2242 0 : sal_Int32 nColor = 0;
2243 0 : if ( Value >>= nColor )
2244 : {
2245 0 : Color aColor( nColor );
2246 0 : pWindow->SetControlForeground( aColor );
2247 : }
2248 : }
2249 : }
2250 : }
2251 0 : break;
2252 : default:
2253 0 : VCLXWindow::setProperty( PropertyName, Value );
2254 0 : break;
2255 : }
2256 0 : }
2257 0 : }
2258 :
2259 0 : ::com::sun::star::uno::Any VCLXProgressBar::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
2260 : {
2261 0 : SolarMutexGuard aGuard;
2262 :
2263 0 : ::com::sun::star::uno::Any aProp;
2264 0 : ProgressBar* pProgressBar = (ProgressBar*)GetWindow();
2265 0 : if ( pProgressBar )
2266 : {
2267 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
2268 0 : switch ( nPropType )
2269 : {
2270 : case BASEPROPERTY_PROGRESSVALUE:
2271 : {
2272 0 : aProp <<= m_nValue;
2273 : }
2274 0 : break;
2275 : case BASEPROPERTY_PROGRESSVALUE_MIN:
2276 : {
2277 0 : aProp <<= m_nValueMin;
2278 : }
2279 0 : break;
2280 : case BASEPROPERTY_PROGRESSVALUE_MAX:
2281 : {
2282 0 : aProp <<= m_nValueMax;
2283 : }
2284 0 : break;
2285 : default:
2286 0 : aProp <<= VCLXWindow::getProperty( PropertyName );
2287 0 : break;
2288 : }
2289 : }
2290 0 : return aProp;
2291 : }
2292 :
2293 0 : void VCLXProgressBar::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2294 : {
2295 : PushPropertyIds( rIds,
2296 : BASEPROPERTY_PROGRESSVALUE,
2297 : BASEPROPERTY_PROGRESSVALUE_MIN,
2298 : BASEPROPERTY_PROGRESSVALUE_MAX,
2299 : BASEPROPERTY_FILLCOLOR,
2300 0 : 0);
2301 0 : VCLXWindow::ImplGetPropertyIds( rIds, true );
2302 0 : }
2303 :
2304 :
2305 : // ----------------------------------------------------
2306 : // class SVTXDateField
2307 : // ----------------------------------------------------
2308 0 : SVTXDateField::SVTXDateField()
2309 0 : :VCLXDateField()
2310 : {
2311 0 : }
2312 :
2313 0 : SVTXDateField::~SVTXDateField()
2314 : {
2315 0 : }
2316 :
2317 0 : void SAL_CALL SVTXDateField::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value ) throw(::com::sun::star::uno::RuntimeException)
2318 : {
2319 0 : VCLXDateField::setProperty( PropertyName, Value );
2320 :
2321 : // some properties need to be forwarded to the sub edit, too
2322 0 : Edit* pSubEdit = GetWindow() ? static_cast< Edit* >( GetWindow() )->GetSubEdit() : NULL;
2323 0 : if ( !pSubEdit )
2324 0 : return;
2325 :
2326 0 : switch ( GetPropertyId( PropertyName ) )
2327 : {
2328 : case BASEPROPERTY_TEXTLINECOLOR:
2329 0 : if ( !Value.hasValue() )
2330 0 : pSubEdit->SetTextLineColor();
2331 : else
2332 : {
2333 0 : sal_Int32 nColor = 0;
2334 0 : if ( Value >>= nColor )
2335 0 : pSubEdit->SetTextLineColor( Color( nColor ) );
2336 : }
2337 0 : break;
2338 : }
2339 : }
2340 :
2341 0 : void SVTXDateField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2342 : {
2343 : PushPropertyIds( rIds,
2344 : BASEPROPERTY_TEXTLINECOLOR,
2345 0 : 0);
2346 0 : VCLXDateField::ImplGetPropertyIds( rIds );
2347 0 : }
2348 :
2349 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
