LibreOffice Module desktop (master)  1
splash.cxx
Go to the documentation of this file.
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 "splash.hxx"
22 #include <sal/log.hxx>
23 #include <vcl/bitmapex.hxx>
24 #include <vcl/svapp.hxx>
25 #include <vcl/salnativewidgets.hxx>
26 
27 #include <com/sun/star/lang/XInitialization.hpp>
28 #include <com/sun/star/lang/XServiceInfo.hpp>
29 #include <com/sun/star/task/XStatusIndicator.hpp>
30 #include <cppuhelper/implbase.hxx>
32 #include <rtl/bootstrap.hxx>
33 #include <rtl/strbuf.hxx>
34 #include <rtl/math.hxx>
35 #include <vcl/introwin.hxx>
36 #include <vcl/virdev.hxx>
37 
38 #define NOT_LOADED (long(-1))
39 #define NOT_LOADED_COLOR (Color(0xffffffff))
40 
41 using namespace ::com::sun::star::lang;
42 using namespace ::com::sun::star::task;
43 using namespace ::com::sun::star::uno;
44 
45 namespace {
46 
47 class SplashScreen;
48 
49 class SplashScreenWindow : public IntroWindow
50 {
51 public:
52  SplashScreen *pSpl;
54  explicit SplashScreenWindow(SplashScreen *);
55  virtual ~SplashScreenWindow() override { disposeOnce(); }
56  virtual void dispose() override;
57  // workwindow
58  virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) override;
59  void Redraw();
60 
61 };
62 
63 class SplashScreen
64  : public ::cppu::WeakImplHelper< XStatusIndicator, XInitialization, XServiceInfo >
65 {
66  friend class SplashScreenWindow;
67 private:
69 
70  DECL_LINK( AppEventListenerHdl, VclSimpleEvent&, void );
71  virtual ~SplashScreen() override;
72  void loadConfig();
73  void updateStatus();
74  void SetScreenBitmap(BitmapEx &rBitmap);
75  static void determineProgressRatioValues( double& rXRelPos, double& rYRelPos, double& rRelWidth, double& rRelHeight );
76 
77  static osl::Mutex _aMutex;
78 
79  BitmapEx _aIntroBmp;
80  Color _cProgressFrameColor;
81  Color _cProgressBarColor;
82  Color _cProgressTextColor;
83  bool _bNativeProgress;
84  OUString _sAppName;
85  OUString _sProgressText;
86 
87  sal_Int32 _iMax;
88  sal_Int32 _iProgress;
89  bool _bPaintProgress;
90  bool _bVisible;
91  bool _bShowLogo;
92  bool _bFullScreenSplash;
93  bool _bProgressEnd;
94  long _height, _width, _tlx, _tly, _barwidth;
95  long _barheight, _barspace, _textBaseline;
96  double _fXPos, _fYPos;
97  double _fWidth, _fHeight;
98  static constexpr long _xoffset = 12, _yoffset = 18;
99 
100 public:
101  SplashScreen();
102 
103  // XStatusIndicator
104  virtual void SAL_CALL end() override;
105  virtual void SAL_CALL reset() override;
106  virtual void SAL_CALL setText(const OUString& aText) override;
107  virtual void SAL_CALL setValue(sal_Int32 nValue) override;
108  virtual void SAL_CALL start(const OUString& aText, sal_Int32 nRange) override;
109 
110  // XInitialize
111  virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any>& aArguments ) override;
112 
113  virtual OUString SAL_CALL getImplementationName() override
115 
116  virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override
117  { return cppu::supportsService(this, ServiceName); }
118 
119  virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
121 };
122 
123 SplashScreenWindow::SplashScreenWindow(SplashScreen *pSplash)
124  : IntroWindow()
125  , pSpl( pSplash )
126  , _vdev(VclPtr<VirtualDevice>::Create(*this))
127 {
128  _vdev->EnableRTL(IsRTLEnabled());
129 }
130 
131 void SplashScreenWindow::dispose()
132 {
133  pSpl = nullptr;
134  IntroWindow::dispose();
135 }
136 
137 void SplashScreenWindow::Redraw()
138 {
139  Invalidate();
140  // Trigger direct painting too - otherwise the splash screen won't be
141  // shown in some cases (when the idle timer won't be hit).
142  Paint(*this, tools::Rectangle());
143  Flush();
144 }
145 
146 SplashScreen::SplashScreen()
147  : pWindow( VclPtr<SplashScreenWindow>::Create(this) )
148  , _cProgressFrameColor(NOT_LOADED_COLOR)
149  , _cProgressBarColor(NOT_LOADED_COLOR)
150  , _cProgressTextColor(NOT_LOADED_COLOR)
151  , _bNativeProgress(true)
152  , _iMax(100)
153  , _iProgress(0)
154  , _bPaintProgress(false)
155  , _bVisible(true)
156  , _bShowLogo(true)
157  , _bFullScreenSplash(false)
158  , _bProgressEnd(false)
159  , _height(0)
160  , _width(0)
161  , _tlx(NOT_LOADED)
162  , _tly(NOT_LOADED)
163  , _barwidth(NOT_LOADED)
164  , _barheight(NOT_LOADED)
165  , _barspace(2)
166  , _textBaseline(NOT_LOADED)
167  , _fXPos(-1.0)
168  , _fYPos(-1.0)
169  , _fWidth(-1.0)
170  , _fHeight(-1.0)
171 {
172  loadConfig();
173 }
174 
175 SplashScreen::~SplashScreen()
176 {
178  LINK( this, SplashScreen, AppEventListenerHdl ) );
179  pWindow->Hide();
180  pWindow.disposeAndClear();
181 }
182 
183 void SAL_CALL SplashScreen::start(const OUString&, sal_Int32 nRange)
184 {
185  _iMax = nRange;
186  if (_bVisible) {
187  _bProgressEnd = false;
188  SolarMutexGuard aSolarGuard;
189  pWindow->Show();
190  pWindow->Redraw();
191  }
192 }
193 
194 void SAL_CALL SplashScreen::end()
195 {
196  _iProgress = _iMax;
197  if (_bVisible )
198  {
199  pWindow->Hide();
200  }
201  _bProgressEnd = true;
202 }
203 
204 void SAL_CALL SplashScreen::reset()
205 {
206  _iProgress = 0;
207  if (_bVisible && !_bProgressEnd )
208  {
209  pWindow->Show();
210  updateStatus();
211  }
212 }
213 
214 void SAL_CALL SplashScreen::setText(const OUString& rText)
215 {
216  SolarMutexGuard aSolarGuard;
217  if ( _sProgressText != rText )
218  {
219  _sProgressText = rText;
220 
221  if (_bVisible && !_bProgressEnd)
222  {
223  pWindow->Show();
224  updateStatus();
225  }
226  }
227 }
228 
229 void SAL_CALL SplashScreen::setValue(sal_Int32 nValue)
230 {
231  SAL_INFO( "desktop.splash", "setValue: " << nValue );
232 
233  SolarMutexGuard aSolarGuard;
234  if (_bVisible && !_bProgressEnd) {
235  pWindow->Show();
236  if (nValue >= _iMax)
237  _iProgress = _iMax;
238  else
239  _iProgress = nValue;
240  updateStatus();
241  }
242 }
243 
244 // XInitialize
245 void SAL_CALL
246 SplashScreen::initialize( const css::uno::Sequence< css::uno::Any>& aArguments )
247 {
248  osl::MutexGuard aGuard( _aMutex );
249  if (!aArguments.hasElements())
250  return;
251 
252  aArguments[0] >>= _bVisible;
253  if (aArguments.getLength() > 1 )
254  aArguments[1] >>= _sAppName;
255 
256  // start to determine bitmap and all other required value
257  if ( _bShowLogo )
258  SetScreenBitmap (_aIntroBmp);
259  Size aSize = _aIntroBmp.GetSizePixel();
260  pWindow->SetOutputSizePixel( aSize );
261  pWindow->_vdev->SetOutputSizePixel( aSize );
262  _height = aSize.Height();
263  _width = aSize.Width();
264  if (_width > 500)
265  {
266  Point xtopleft(212,216);
267  if ( NOT_LOADED == _tlx || NOT_LOADED == _tly )
268  {
269  _tlx = xtopleft.X(); // top-left x
270  _tly = xtopleft.Y(); // top-left y
271  }
272  if ( NOT_LOADED == _barwidth )
273  _barwidth = 263;
274  if ( NOT_LOADED == _barheight )
275  _barheight = 8;
276  }
277  else
278  {
279  if ( NOT_LOADED == _barwidth )
280  _barwidth = _width - (2 * _xoffset);
281  if ( NOT_LOADED == _barheight )
282  _barheight = 6;
283  if ( NOT_LOADED == _tlx || NOT_LOADED == _tly )
284  {
285  _tlx = _xoffset; // top-left x
286  _tly = _height - _yoffset; // top-left y
287  }
288  }
289 
290  if ( NOT_LOADED == _textBaseline )
291  _textBaseline = _height;
292 
293  if ( NOT_LOADED_COLOR == _cProgressFrameColor )
294  _cProgressFrameColor = COL_LIGHTGRAY;
295 
296  if ( NOT_LOADED_COLOR == _cProgressBarColor )
297  {
298  // progress bar: new color only for big bitmap format
299  if ( _width > 500 )
300  _cProgressBarColor = Color( 157, 202, 18 );
301  else
302  _cProgressBarColor = COL_BLUE;
303  }
304 
305  if ( NOT_LOADED_COLOR == _cProgressTextColor )
306  _cProgressTextColor = COL_BLACK;
307 
309  LINK( this, SplashScreen, AppEventListenerHdl ) );
310 }
311 
312 void SplashScreen::updateStatus()
313 {
314  if (!_bVisible || _bProgressEnd)
315  return;
316  if (!_bPaintProgress)
317  _bPaintProgress = true;
318  pWindow->Redraw();
319 }
320 
321 // internal private methods
322 IMPL_LINK( SplashScreen, AppEventListenerHdl, VclSimpleEvent&, inEvent, void )
323 {
324  if (static_cast<VclWindowEvent&>(inEvent).GetWindow() == pWindow)
325  {
326  switch ( inEvent.GetId() )
327  {
328  case VclEventId::WindowShow:
329  pWindow->Redraw();
330  break;
331  default:
332  break;
333  }
334  }
335 }
336 
337 // Read keys from soffice{.ini|rc}:
338 OUString implReadBootstrapKey( const OUString& _rKey )
339 {
340  OUString sValue;
341  rtl::Bootstrap::get(_rKey, sValue);
342  return sValue;
343 }
344 
345 void SplashScreen::loadConfig()
346 {
347  _bShowLogo = implReadBootstrapKey( "Logo" ) != "0";
348 
349  OUString sProgressFrameColor = implReadBootstrapKey( "ProgressFrameColor" );
350  OUString sProgressBarColor = implReadBootstrapKey( "ProgressBarColor" );
351  OUString sProgressTextColor = implReadBootstrapKey( "ProgressTextColor" );
352  OUString sProgressTextBaseline = implReadBootstrapKey( "ProgressTextBaseline" );
353  OUString sSize = implReadBootstrapKey( "ProgressSize" );
354  OUString sPosition = implReadBootstrapKey( "ProgressPosition" );
355  OUString sFullScreenSplash = implReadBootstrapKey( "FullScreenSplash" );
356  OUString sNativeProgress = implReadBootstrapKey( "NativeProgress" );
357 
358 
359  // Determine full screen splash mode
360  _bFullScreenSplash = (( !sFullScreenSplash.isEmpty() ) &&
361  ( sFullScreenSplash != "0" ));
362 
363  // Try to retrieve the relative values for the progress bar. The current
364  // schema uses the screen ratio to retrieve the associated values.
365  if ( _bFullScreenSplash )
366  determineProgressRatioValues( _fXPos, _fYPos, _fWidth, _fHeight );
367 
368  if ( !sProgressFrameColor.isEmpty() )
369  {
370  sal_uInt8 nRed = 0;
371  sal_Int32 idx = 0;
372  sal_Int32 temp = sProgressFrameColor.getToken( 0, ',', idx ).toInt32();
373  if ( idx != -1 )
374  {
375  nRed = static_cast< sal_uInt8 >( temp );
376  temp = sProgressFrameColor.getToken( 0, ',', idx ).toInt32();
377  }
378  if ( idx != -1 )
379  {
380  sal_uInt8 nGreen = static_cast< sal_uInt8 >( temp );
381  sal_uInt8 nBlue = static_cast< sal_uInt8 >( sProgressFrameColor.getToken( 0, ',', idx ).toInt32() );
382  _cProgressFrameColor = Color( nRed, nGreen, nBlue );
383  }
384  }
385 
386  if ( !sProgressBarColor.isEmpty() )
387  {
388  sal_uInt8 nRed = 0;
389  sal_Int32 idx = 0;
390  sal_Int32 temp = sProgressBarColor.getToken( 0, ',', idx ).toInt32();
391  if ( idx != -1 )
392  {
393  nRed = static_cast< sal_uInt8 >( temp );
394  temp = sProgressBarColor.getToken( 0, ',', idx ).toInt32();
395  }
396  if ( idx != -1 )
397  {
398  sal_uInt8 nGreen = static_cast< sal_uInt8 >( temp );
399  sal_uInt8 nBlue = static_cast< sal_uInt8 >( sProgressBarColor.getToken( 0, ',', idx ).toInt32() );
400  _cProgressBarColor = Color( nRed, nGreen, nBlue );
401  }
402  }
403 
404  if ( !sProgressTextColor.isEmpty() )
405  {
406  sal_uInt8 nRed = 0;
407  sal_Int32 idx = 0;
408  sal_Int32 temp = sProgressTextColor.getToken( 0, ',', idx ).toInt32();
409  if ( idx != -1 )
410  {
411  nRed = static_cast< sal_uInt8 >( temp );
412  temp = sProgressTextColor.getToken( 0, ',', idx ).toInt32();
413  }
414  if ( idx != -1 )
415  {
416  sal_uInt8 nGreen = static_cast< sal_uInt8 >( temp );
417  sal_uInt8 nBlue = static_cast< sal_uInt8 >( sProgressTextColor.getToken( 0, ',', idx ).toInt32() );
418  _cProgressTextColor = Color( nRed, nGreen, nBlue );
419  }
420  }
421 
422  if ( !sProgressTextBaseline.isEmpty() )
423  {
424  _textBaseline = sProgressTextBaseline.toInt32();
425  }
426 
427  if( !sNativeProgress.isEmpty() )
428  {
429  _bNativeProgress = sNativeProgress.toBoolean();
430  }
431 
432  if ( !sSize.isEmpty() )
433  {
434  sal_Int32 idx = 0;
435  sal_Int32 temp = sSize.getToken( 0, ',', idx ).toInt32();
436  if ( idx != -1 )
437  {
438  _barwidth = temp;
439  _barheight = sSize.getToken( 0, ',', idx ).toInt32();
440  }
441  }
442 
443  if ( _barheight >= 10 )
444  _barspace = 3; // more space between frame and bar
445 
446  if ( !sPosition.isEmpty() )
447  {
448  sal_Int32 idx = 0;
449  sal_Int32 temp = sPosition.getToken( 0, ',', idx ).toInt32();
450  if ( idx != -1 )
451  {
452  _tlx = temp;
453  _tly = sPosition.getToken( 0, ',', idx ).toInt32();
454  }
455  }
456 }
457 
458 void SplashScreen::SetScreenBitmap(BitmapEx &rBitmap)
459 {
460  sal_Int32 nWidth( 0 );
461  sal_Int32 nHeight( 0 );
462 
463  // determine desktop resolution
464  sal_uInt32 nCount = Application::GetScreenCount();
465  if ( nCount > 0 )
466  {
467  // retrieve size from first screen
468  tools::Rectangle aScreenArea = Application::GetScreenPosSizePixel(static_cast<unsigned int>(0));
469  nWidth = aScreenArea.GetWidth();
470  nHeight = aScreenArea.GetHeight();
471  }
472 
473  // create file name from screen resolution information
474  OStringBuffer aStrBuf( 128 );
475  aStrBuf.append( "intro_" );
476  if ( !_sAppName.isEmpty() )
477  {
478  aStrBuf.append( OUStringToOString(_sAppName, RTL_TEXTENCODING_UTF8) );
479  aStrBuf.append( "_" );
480  }
481  OString aResBuf = OString::number( nWidth ) + "x" + OString::number( nHeight );
482 
483  aStrBuf.append( aResBuf.getStr() );
484  if (Application::LoadBrandBitmap (aStrBuf.makeStringAndClear().getStr(), rBitmap))
485  return;
486 
487  aStrBuf.append( "intro_" );
488  aStrBuf.append( aResBuf.getStr() );
489  if (Application::LoadBrandBitmap (aResBuf.getStr(), rBitmap))
490  return;
491 
492  (void)Application::LoadBrandBitmap ("intro", rBitmap);
493 }
494 
495 void SplashScreen::determineProgressRatioValues(
496  double& rXRelPos, double& rYRelPos,
497  double& rRelWidth, double& rRelHeight )
498 {
499  sal_Int32 nWidth( 0 );
500  sal_Int32 nHeight( 0 );
501  sal_Int32 nScreenRatio( 0 );
502 
503  // determine desktop resolution
504  sal_uInt32 nCount = Application::GetScreenCount();
505  if ( nCount > 0 )
506  {
507  // retrieve size from first screen
508  tools::Rectangle aScreenArea = Application::GetScreenPosSizePixel(static_cast<unsigned int>(0));
509  nWidth = aScreenArea.GetWidth();
510  nHeight = aScreenArea.GetHeight();
511  nScreenRatio = nHeight ? sal_Int32( rtl::math::round( double( nWidth ) / double( nHeight ), 2 ) * 100 ) : 0;
512  }
513 
514  char szFullScreenProgressRatio[] = "FullScreenProgressRatio0";
515  char szFullScreenProgressPos[] = "FullScreenProgressPos0";
516  char szFullScreenProgressSize[] = "FullScreenProgressSize0";
517  for ( sal_Int32 i = 0; i <= 9; i++ )
518  {
519  char cNum = '0' + char( i );
520  szFullScreenProgressRatio[23] = cNum;
521  szFullScreenProgressPos[21] = cNum;
522  szFullScreenProgressSize[22] = cNum;
523 
524  OUString sFullScreenProgressRatio = implReadBootstrapKey(
525  OUString::createFromAscii( szFullScreenProgressRatio ) );
526 
527  if ( !sFullScreenProgressRatio.isEmpty() )
528  {
529  double fRatio = sFullScreenProgressRatio.toDouble();
530  sal_Int32 nRatio = sal_Int32( rtl::math::round( fRatio, 2 ) * 100 );
531  if ( nRatio == nScreenRatio )
532  {
533  OUString sFullScreenProgressPos = implReadBootstrapKey(
534  OUString::createFromAscii( szFullScreenProgressPos ) );
535  OUString sFullScreenProgressSize = implReadBootstrapKey(
536  OUString::createFromAscii( szFullScreenProgressSize ) );
537 
538  if ( !sFullScreenProgressPos.isEmpty() )
539  {
540  sal_Int32 idx = 0;
541  double temp = sFullScreenProgressPos.getToken( 0, ',', idx ).toDouble();
542  if ( idx != -1 )
543  {
544  rXRelPos = temp;
545  rYRelPos = sFullScreenProgressPos.getToken( 0, ',', idx ).toDouble();
546  }
547  }
548 
549  if ( !sFullScreenProgressSize.isEmpty() )
550  {
551  sal_Int32 idx = 0;
552  double temp = sFullScreenProgressSize.getToken( 0, ',', idx ).toDouble();
553  if ( idx != -1 )
554  {
555  rRelWidth = temp;
556  rRelHeight = sFullScreenProgressSize.getToken( 0, ',', idx ).toDouble();
557  }
558  }
559  }
560  }
561  else
562  break;
563  }
564 }
565 
566 void SplashScreenWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
567 {
568  if (!pSpl || !pSpl->_bVisible)
569  return;
570 
571  //native drawing
572  // in case of native controls we need to draw directly to the window
573  if (pSpl->_bNativeProgress && rRenderContext.IsNativeControlSupported(ControlType::IntroProgress, ControlPart::Entire))
574  {
575  rRenderContext.DrawBitmapEx(Point(), pSpl->_aIntroBmp);
576 
577  ImplControlValue aValue( pSpl->_iProgress * pSpl->_barwidth / pSpl->_iMax);
578  tools::Rectangle aDrawRect( Point(pSpl->_tlx, pSpl->_tly), Size( pSpl->_barwidth, pSpl->_barheight));
579  tools::Rectangle aNativeControlRegion, aNativeContentRegion;
580 
581  if (rRenderContext.GetNativeControlRegion(ControlType::IntroProgress, ControlPart::Entire, aDrawRect,
582  ControlState::ENABLED, aValue,
583  aNativeControlRegion, aNativeContentRegion))
584  {
585  long nProgressHeight = aNativeControlRegion.GetHeight();
586  aDrawRect.AdjustTop( -((nProgressHeight - pSpl->_barheight)/2) );
587  aDrawRect.AdjustBottom((nProgressHeight - pSpl->_barheight)/2 );
588  }
589 
590  if (rRenderContext.DrawNativeControl(ControlType::IntroProgress, ControlPart::Entire, aDrawRect,
591  ControlState::ENABLED, aValue, pSpl->_sProgressText))
592  {
593  return;
594  }
595  }
596 
597  // non native drawing
598  // draw bitmap
599  _vdev->DrawBitmapEx(Point(), pSpl->_aIntroBmp);
600 
601  if (pSpl->_bPaintProgress) {
602  // draw progress...
603  long length = (pSpl->_iProgress * pSpl->_barwidth / pSpl->_iMax) - (2 * pSpl->_barspace);
604  if (length < 0) length = 0;
605 
606  // border
607  _vdev->SetFillColor();
608  _vdev->SetLineColor( pSpl->_cProgressFrameColor );
609  _vdev->DrawRect(tools::Rectangle(pSpl->_tlx, pSpl->_tly, pSpl->_tlx+pSpl->_barwidth, pSpl->_tly+pSpl->_barheight));
610  _vdev->SetFillColor( pSpl->_cProgressBarColor );
611  _vdev->SetLineColor();
612  _vdev->DrawRect(tools::Rectangle(pSpl->_tlx+pSpl->_barspace, pSpl->_tly+pSpl->_barspace, pSpl->_tlx+pSpl->_barspace+length, pSpl->_tly+pSpl->_barheight-pSpl->_barspace));
613  vcl::Font aFont;
614  aFont.SetFontSize(Size(0, 12));
616  _vdev->SetFont(aFont);
617  _vdev->SetTextColor(pSpl->_cProgressTextColor);
618  _vdev->DrawText(Point(pSpl->_tlx, pSpl->_textBaseline), pSpl->_sProgressText);
619  }
620  rRenderContext.DrawOutDev(Point(), GetOutputSizePixel(), Point(), _vdev->GetOutputSizePixel(), *_vdev);
621 }
622 
623 
624 // get service instance...
625 osl::Mutex SplashScreen::_aMutex;
626 
627 }
628 
629 css::uno::Reference< css::uno::XInterface > desktop::splash::create(
630  css::uno::Reference< css::uno::XComponentContext > const &)
631 {
632  return static_cast< cppu::OWeakObject * >(new SplashScreen);
633 }
634 
636  return "com.sun.star.office.comp.SplashScreen";
637 }
638 
639 css::uno::Sequence< OUString > desktop::splash::getSupportedServiceNames()
640 {
641  return { "com.sun.star.office.SplashScreen" };
642 }
643 
644 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey, rtl_uString *keyName, RegValueType valueType, RegValue pData, sal_uInt32 valueSize)
long Width() const
long GetWidth() const
void SetFontSize(const Size &)
long GetHeight() const
constexpr::Color COL_BLACK(0x00, 0x00, 0x00)
bool DrawNativeControl(ControlType nType, ControlPart nPart, const tools::Rectangle &rControlRegion, ControlState nState, const ImplControlValue &aValue, const OUString &aCaption)
bool GetNativeControlRegion(ControlType nType, ControlPart nPart, const tools::Rectangle &rControlRegion, ControlState nState, const ImplControlValue &aValue, tools::Rectangle &rNativeBoundingRegion, tools::Rectangle &rNativeContentRegion) const
long Height() const
void DrawBitmapEx(const Point &rDestPt, const BitmapEx &rBitmapEx)
static void RemoveEventListener(const Link< VclSimpleEvent &, void > &rEventListener)
OUString getImplementationName()
Definition: splash.cxx:635
constexpr::Color COL_LIGHTGRAY(0xC0, 0xC0, 0xC0)
static void AddEventListener(const Link< VclSimpleEvent &, void > &rEventListener)
bool IsNativeControlSupported(ControlType nType, ControlPart nPart) const
Mutex _aMutex
long AdjustBottom(long nVertMoveDelta)
Sequence< PropertyValue > aArguments
length
int nCount
bool CPPUHELPER_DLLPUBLIC supportsService(css::lang::XServiceInfo *implementation, rtl::OUString const &name)
void SetAlignment(FontAlign)
static tools::Rectangle GetScreenPosSizePixel(unsigned int nScreen)
ALIGN_BASELINE
css::uno::Sequence< OUString > getSupportedServiceNames()
Definition: splash.cxx:639
int i
css::uno::Reference< css::uno::XInterface > create(css::uno::Reference< css::uno::XComponentContext > const &)
Definition: splash.cxx:629
unsigned char sal_Bool
static unsigned int GetScreenCount()
enumrange< T >::Iterator end(enumrange< T >)
OString OUStringToOString(const OUString &str, ConnectionSettings const *settings)
unsigned char sal_uInt8
#define SAL_INFO(area, stream)
#define NOT_LOADED
Definition: splash.cxx:38
long AdjustTop(long nVertMoveDelta)
#define NOT_LOADED_COLOR
Definition: splash.cxx:39
constexpr::Color COL_BLUE(0x00, 0x00, 0x80)
void dispose()
static bool LoadBrandBitmap(const char *pName, BitmapEx &rBitmap)
SAL_DLLPRIVATE void DrawOutDev(const Point &, const Size &, const Point &, const Size &, const Printer &)=delete
sal_Int16 nValue
IMPL_LINK(ExtMgrDialog, startProgress, void *, _bLockInterface, void)
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo