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