1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_desktop.hxx" 26 27 #include <introbmpnames.hxx> 28 #include "splash.hxx" 29 #include <stdio.h> 30 #include <unotools/bootstrap.hxx> 31 #include <vos/process.hxx> 32 #include <tools/urlobj.hxx> 33 #include <tools/stream.hxx> 34 #include <sfx2/sfx.hrc> 35 #include <vcl/svapp.hxx> 36 #include <vcl/salnativewidgets.hxx> 37 38 #include <com/sun/star/registry/XRegistryKey.hpp> 39 #include <rtl/bootstrap.hxx> 40 #include <rtl/logfile.hxx> 41 #include <rtl/ustrbuf.hxx> 42 #include <rtl/math.hxx> 43 #include <vcl/graph.hxx> 44 #include <svtools/filter.hxx> 45 46 #define NOT_LOADED ((long)-1) 47 48 using namespace ::rtl; 49 using namespace ::com::sun::star::registry; 50 51 namespace desktop 52 { 53 54 SplashScreen::SplashScreen(const Reference< XMultiServiceFactory >& rSMgr) 55 : IntroWindow() 56 , _vdev(*((IntroWindow*)this)) 57 , _cProgressFrameColor(sal::static_int_cast< ColorData >(NOT_LOADED)) 58 , _bShowProgressFrame(true) 59 , _cProgressBarColor(sal::static_int_cast< ColorData >(NOT_LOADED)) 60 , _bNativeProgress(true) 61 , _iMax(100) 62 , _iProgress(0) 63 , _eBitmapMode(BM_DEFAULTMODE) 64 , _bPaintBitmap(sal_True) 65 , _bPaintProgress(sal_False) 66 , _bShowLogo(sal_True) 67 , _bFullScreenSplash(sal_False) 68 , _bProgressEnd(sal_False) 69 , _tlx(NOT_LOADED) 70 , _tly(NOT_LOADED) 71 , _barwidth(NOT_LOADED) 72 , _barheight(NOT_LOADED) 73 , _barspace(2) 74 , _fXPos(-1.0) 75 , _fYPos(-1.0) 76 , _fWidth(-1.0) 77 , _fHeight(-1.0) 78 , _xoffset(12) 79 , _yoffset(18) 80 { 81 _rFactory = rSMgr; 82 83 loadConfig(); 84 } 85 86 SplashScreen::~SplashScreen() 87 { 88 Application::RemoveEventListener( 89 LINK( this, SplashScreen, AppEventListenerHdl ) ); 90 Hide(); 91 92 } 93 94 void SAL_CALL SplashScreen::start(const OUString&, sal_Int32 nRange) 95 throw (RuntimeException) 96 { 97 _iMax = nRange; 98 if (_bVisible) { 99 _bProgressEnd = sal_False; 100 ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); 101 if ( _eBitmapMode == BM_FULLSCREEN ) 102 ShowFullScreenMode( sal_True ); 103 Show(); 104 Paint(Rectangle()); 105 Flush(); 106 } 107 } 108 109 void SAL_CALL SplashScreen::end() 110 throw (RuntimeException) 111 { 112 _iProgress = _iMax; 113 if (_bVisible ) 114 { 115 if ( _eBitmapMode == BM_FULLSCREEN ) 116 EndFullScreenMode(); 117 Hide(); 118 } 119 _bProgressEnd = sal_True; 120 } 121 122 void SAL_CALL SplashScreen::reset() 123 throw (RuntimeException) 124 { 125 _iProgress = 0; 126 if (_bVisible && !_bProgressEnd ) 127 { 128 if ( _eBitmapMode == BM_FULLSCREEN ) 129 ShowFullScreenMode( sal_True ); 130 Show(); 131 updateStatus(); 132 } 133 } 134 135 void SAL_CALL SplashScreen::setText(const OUString& rText) 136 throw (RuntimeException) 137 { 138 ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); 139 if ( _sProgressText != rText ) 140 { 141 _sProgressText = rText; 142 143 if (_bVisible && !_bProgressEnd) 144 { 145 if ( _eBitmapMode == BM_FULLSCREEN ) 146 ShowFullScreenMode( sal_True ); 147 Show(); 148 updateStatus(); 149 } 150 } 151 } 152 153 void SAL_CALL SplashScreen::setValue(sal_Int32 nValue) 154 throw (RuntimeException) 155 { 156 RTL_LOGFILE_CONTEXT( aLog, "::SplashScreen::setValue (lo119109)" ); 157 RTL_LOGFILE_CONTEXT_TRACE1( aLog, "value=%d", nValue ); 158 159 ::vos::OGuard aSolarGuard( Application::GetSolarMutex() ); 160 if (_bVisible && !_bProgressEnd) { 161 if ( _eBitmapMode == BM_FULLSCREEN ) 162 ShowFullScreenMode( sal_True ); 163 Show(); 164 if (nValue >= _iMax) _iProgress = _iMax; 165 else _iProgress = nValue; 166 updateStatus(); 167 } 168 } 169 170 // XInitialize 171 void SAL_CALL 172 SplashScreen::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any>& aArguments ) 173 throw (RuntimeException) 174 { 175 ::osl::ClearableMutexGuard aGuard( _aMutex ); 176 if (aArguments.getLength() > 0) 177 { 178 aArguments[0] >>= _bVisible; 179 if (aArguments.getLength() > 1 ) 180 aArguments[1] >>= _sAppName; 181 182 // start to determine bitmap and all other required value 183 initBitmap(); 184 Size aSize = _aIntroBmp.GetSizePixel(); 185 SetOutputSizePixel( aSize ); 186 _vdev.SetOutputSizePixel( aSize ); 187 _height = aSize.Height(); 188 _width = aSize.Width(); 189 if (_width > 500) 190 { 191 Point xtopleft(212,216); 192 if ( NOT_LOADED == _tlx || NOT_LOADED == _tly ) 193 { 194 _tlx = xtopleft.X(); // top-left x 195 _tly = xtopleft.Y(); // top-left y 196 } 197 if ( NOT_LOADED == _barwidth ) 198 _barwidth = 263; 199 if ( NOT_LOADED == _barheight ) 200 _barheight = 8; 201 if (( _eBitmapMode == BM_FULLSCREEN ) && 202 _bFullScreenSplash ) 203 { 204 if( ( _fXPos >= 0.0 ) && ( _fYPos >= 0.0 )) 205 { 206 _tlx = sal_Int32( double( aSize.Width() ) * _fXPos ); 207 _tly = sal_Int32( double( aSize.Height() ) * _fYPos ); 208 } 209 if ( _fWidth >= 0.0 ) 210 _barwidth = sal_Int32( double( aSize.Width() ) * _fWidth ); 211 if ( _fHeight >= 0.0 ) 212 _barheight = sal_Int32( double( aSize.Width() ) * _fHeight ); 213 } 214 } 215 else 216 { 217 if ( NOT_LOADED == _barwidth ) 218 _barwidth = _width - (2 * _xoffset); 219 if ( NOT_LOADED == _barheight ) 220 _barheight = 6; 221 if ( NOT_LOADED == _tlx || NOT_LOADED == _tly ) 222 { 223 _tlx = _xoffset; // top-left x 224 _tly = _height - _yoffset; // top-left y 225 } 226 } 227 228 if ( sal::static_int_cast< ColorData >(NOT_LOADED) == 229 _cProgressFrameColor.GetColor() ) 230 _cProgressFrameColor = Color( COL_LIGHTGRAY ); 231 232 if ( sal::static_int_cast< ColorData >(NOT_LOADED) == 233 _cProgressBarColor.GetColor() ) 234 { 235 // progress bar: new color only for big bitmap format 236 if ( _width > 500 ) 237 _cProgressBarColor = Color( 157, 202, 18 ); 238 else 239 _cProgressBarColor = Color( COL_BLUE ); 240 } 241 242 Application::AddEventListener( 243 LINK( this, SplashScreen, AppEventListenerHdl ) ); 244 245 SetBackgroundBitmap( _aIntroBmp ); 246 } 247 } 248 249 void SplashScreen::updateStatus() 250 { 251 if (!_bVisible || _bProgressEnd) return; 252 if (!_bPaintProgress) _bPaintProgress = sal_True; 253 //_bPaintBitmap=sal_False; 254 Paint(Rectangle()); 255 //_bPaintBitmap=sal_True; 256 Flush(); 257 } 258 259 // internal private methods 260 IMPL_LINK( SplashScreen, AppEventListenerHdl, VclWindowEvent *, inEvent ) 261 { 262 if ( inEvent != 0 ) 263 { 264 // Paint( Rectangle() ); 265 switch ( inEvent->GetId() ) 266 { 267 case VCLEVENT_WINDOW_SHOW: 268 Paint( Rectangle() ); 269 break; 270 default: 271 break; 272 } 273 } 274 return 0; 275 } 276 277 // Read keys from edition/edition.ini or soffice{.ini|rc}: 278 OUString implReadBootstrapKey( const OUString& _rKey ) 279 { 280 OUString sValue( 281 rtl::OUString( 282 RTL_CONSTASCII_USTRINGPARAM( 283 "${.override:${OOO_BASE_DIR}/program/edition/edition.ini:")) + 284 _rKey + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("}"))); 285 rtl::Bootstrap::expandMacros(sValue); 286 return sValue; 287 } 288 289 void SplashScreen::loadConfig() 290 { 291 _bShowLogo = !implReadBootstrapKey( 292 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Logo"))). 293 equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("0")); 294 295 OUString sProgressFrameColor = implReadBootstrapKey( 296 OUString( RTL_CONSTASCII_USTRINGPARAM( "ProgressFrameColor" ) ) ); 297 OUString sProgressBarColor = implReadBootstrapKey( 298 OUString( RTL_CONSTASCII_USTRINGPARAM( "ProgressBarColor" ) ) ); 299 OUString sSize = implReadBootstrapKey( 300 OUString( RTL_CONSTASCII_USTRINGPARAM( "ProgressSize" ) ) ); 301 OUString sPosition = implReadBootstrapKey( 302 OUString( RTL_CONSTASCII_USTRINGPARAM( "ProgressPosition" ) ) ); 303 OUString sFullScreenSplash = implReadBootstrapKey( 304 OUString( RTL_CONSTASCII_USTRINGPARAM( "FullScreenSplash" ) ) ); 305 OUString sNativeProgress = implReadBootstrapKey( 306 OUString( RTL_CONSTASCII_USTRINGPARAM( "NativeProgress" ) ) ); 307 OUString sShowProgressFrame = implReadBootstrapKey( 308 OUString( RTL_CONSTASCII_USTRINGPARAM( "ShowProgressFrame" ) ) ); 309 310 311 // Determine full screen splash mode 312 _bFullScreenSplash = (( sFullScreenSplash.getLength() > 0 ) && 313 ( !sFullScreenSplash.equalsAsciiL( "0", 1 ))); 314 315 // Try to retrieve the relative values for the progress bar. The current 316 // schema uses the screen ratio to retrieve the associated values. 317 if ( _bFullScreenSplash ) 318 determineProgressRatioValues( _fXPos, _fYPos, _fWidth, _fHeight ); 319 320 if ( sProgressFrameColor.getLength() ) 321 { 322 sal_uInt8 nRed = 0; 323 sal_uInt8 nGreen = 0; 324 sal_uInt8 nBlue = 0; 325 sal_Int32 idx = 0; 326 sal_Int32 temp = sProgressFrameColor.getToken( 0, ',', idx ).toInt32(); 327 if ( idx != -1 ) 328 { 329 nRed = static_cast< sal_uInt8 >( temp ); 330 temp = sProgressFrameColor.getToken( 0, ',', idx ).toInt32(); 331 } 332 if ( idx != -1 ) 333 { 334 nGreen = static_cast< sal_uInt8 >( temp ); 335 nBlue = static_cast< sal_uInt8 >( sProgressFrameColor.getToken( 0, ',', idx ).toInt32() ); 336 _cProgressFrameColor = Color( nRed, nGreen, nBlue ); 337 } 338 } 339 340 if (sShowProgressFrame.getLength() > 0) 341 { 342 _bShowProgressFrame = sShowProgressFrame.toBoolean(); 343 } 344 345 if ( sProgressBarColor.getLength() ) 346 { 347 sal_uInt8 nRed = 0; 348 sal_uInt8 nGreen = 0; 349 sal_uInt8 nBlue = 0; 350 sal_Int32 idx = 0; 351 sal_Int32 temp = sProgressBarColor.getToken( 0, ',', idx ).toInt32(); 352 if ( idx != -1 ) 353 { 354 nRed = static_cast< sal_uInt8 >( temp ); 355 temp = sProgressBarColor.getToken( 0, ',', idx ).toInt32(); 356 } 357 if ( idx != -1 ) 358 { 359 nGreen = static_cast< sal_uInt8 >( temp ); 360 nBlue = static_cast< sal_uInt8 >( sProgressBarColor.getToken( 0, ',', idx ).toInt32() ); 361 _cProgressBarColor = Color( nRed, nGreen, nBlue ); 362 } 363 } 364 365 if( sNativeProgress.getLength() ) 366 { 367 _bNativeProgress = sNativeProgress.toBoolean(); 368 } 369 370 if ( sSize.getLength() ) 371 { 372 sal_Int32 idx = 0; 373 sal_Int32 temp = sSize.getToken( 0, ',', idx ).toInt32(); 374 if ( idx != -1 ) 375 { 376 _barwidth = temp; 377 _barheight = sSize.getToken( 0, ',', idx ).toInt32(); 378 } 379 } 380 381 if ( _barheight >= 10 ) 382 _barspace = 3; // more space between frame and bar 383 384 if ( sPosition.getLength() ) 385 { 386 sal_Int32 idx = 0; 387 sal_Int32 temp = sPosition.getToken( 0, ',', idx ).toInt32(); 388 if ( idx != -1 ) 389 { 390 _tlx = temp; 391 _tly = sPosition.getToken( 0, ',', idx ).toInt32(); 392 } 393 } 394 } 395 396 void SplashScreen::initBitmap() 397 { 398 if ( _bShowLogo ) 399 { 400 OUString sExecutePath; 401 ::rtl::Bootstrap::get( 402 OUString( RTL_CONSTASCII_USTRINGPARAM( "OOO_BASE_DIR" ) ), 403 sExecutePath ); 404 sExecutePath += OUString( RTL_CONSTASCII_USTRINGPARAM( "/program/" ) ); 405 406 bool haveBitmap = false; 407 408 // Try all bitmaps in INTRO_BITMAP_NAMES 409 sal_Int32 nIndex = 0; 410 OUString aIntroBitmapFiles( RTL_CONSTASCII_USTRINGPARAM( INTRO_BITMAP_STRINGLIST )); 411 do 412 { 413 haveBitmap = loadBitmap( sExecutePath, aIntroBitmapFiles.getToken( 0, ',', nIndex ) ); 414 } 415 while ( !haveBitmap && ( nIndex >= 0 ) ); 416 417 if (!haveBitmap) { 418 rtl::OUString edition( 419 rtl::OUString( 420 RTL_CONSTASCII_USTRINGPARAM( 421 "${OOO_BASE_DIR}/program/edition"))); 422 rtl::Bootstrap::expandMacros(edition); 423 haveBitmap = findBitmap(edition); 424 } 425 if (!haveBitmap) { 426 findBitmap(sExecutePath); 427 } 428 } 429 } 430 431 bool SplashScreen::loadBitmap( 432 rtl::OUString const & path, const rtl::OUString &rBmpFileName ) 433 { 434 if ( rBmpFileName.getLength() == 0 ) 435 return false; 436 437 INetURLObject aObj( path, INET_PROT_FILE ); 438 aObj.insertName( rBmpFileName ); 439 440 SvFileStream aStrm( aObj.PathToFileName(), STREAM_STD_READ ); 441 if ( !aStrm.GetError() ) 442 { 443 // Use graphic class to also support more graphic formats (bmp,png,...) 444 Graphic aGraphic; 445 446 GraphicFilter* pGF = GraphicFilter::GetGraphicFilter(); 447 pGF->ImportGraphic( aGraphic, String(), aStrm, GRFILTER_FORMAT_DONTKNOW ); 448 449 // Default case, we load the intro bitmap from a seperate file 450 // (e.g. staroffice_intro.bmp or starsuite_intro.bmp) 451 _aIntroBmp = aGraphic.GetBitmapEx(); 452 return true; 453 } 454 455 return false; 456 } 457 458 bool SplashScreen::findBitmap(rtl::OUString const & path) { 459 bool haveBitmap = false; 460 if ( _bFullScreenSplash ) 461 { 462 haveBitmap = findScreenBitmap(path); 463 if ( haveBitmap ) 464 _eBitmapMode = BM_FULLSCREEN; 465 else 466 haveBitmap = findAppBitmap(path); 467 } 468 if ( !haveBitmap ) 469 { 470 haveBitmap = loadBitmap( 471 path, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("intro.png"))); 472 if ( !haveBitmap ) 473 haveBitmap = loadBitmap( 474 path, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("intro.bmp"))); 475 } 476 477 return haveBitmap; 478 } 479 480 bool SplashScreen::findScreenBitmap(rtl::OUString const & path) 481 { 482 sal_Int32 nWidth( 0 ); 483 sal_Int32 nHeight( 0 ); 484 485 // determine desktop resolution 486 sal_uInt32 nCount = Application::GetScreenCount(); 487 if ( nCount > 0 ) 488 { 489 // retrieve size from first screen 490 Rectangle aScreenArea = Application::GetScreenPosSizePixel((unsigned int)0); 491 nWidth = aScreenArea.GetWidth(); 492 nHeight = aScreenArea.GetHeight(); 493 } 494 495 // create file name from screen resolution information 496 OUStringBuffer aStrBuf( 128 ); 497 aStrBuf.appendAscii( "intro_" ); 498 if ( _sAppName.getLength() > 0 ) 499 { 500 aStrBuf.append( _sAppName ); 501 aStrBuf.appendAscii( "_" ); 502 } 503 aStrBuf.append( OUString::valueOf( nWidth )); 504 aStrBuf.appendAscii( "x" ); 505 aStrBuf.append( OUString::valueOf( nHeight )); 506 507 OUString aRootIntroFileName = aStrBuf.makeStringAndClear(); 508 OUString aBmpFileName = aRootIntroFileName + OUString::createFromAscii(".png"); 509 510 bool haveBitmap = loadBitmap( path, aBmpFileName ); 511 if ( !haveBitmap ) 512 { 513 aBmpFileName = aRootIntroFileName + OUString::createFromAscii(".bmp"); 514 haveBitmap = loadBitmap( path, aBmpFileName ); 515 } 516 517 if ( !haveBitmap ) 518 { 519 aStrBuf.appendAscii( "intro_" ); 520 aStrBuf.appendAscii( "_" ); 521 aStrBuf.append( OUString::valueOf( nWidth )); 522 aStrBuf.appendAscii( "x" ); 523 aStrBuf.append( OUString::valueOf( nHeight )); 524 525 aRootIntroFileName = aStrBuf.makeStringAndClear(); 526 aBmpFileName = aRootIntroFileName + OUString::createFromAscii(".png"); 527 528 haveBitmap = loadBitmap( path, aBmpFileName ); 529 if ( !haveBitmap ) 530 { 531 aBmpFileName = aRootIntroFileName + OUString::createFromAscii(".bmp"); 532 haveBitmap = loadBitmap( path, aBmpFileName ); 533 } 534 } 535 return haveBitmap; 536 } 537 538 bool SplashScreen::findAppBitmap(rtl::OUString const & path) 539 { 540 bool haveBitmap = false; 541 542 if ( _sAppName.getLength() > 0 ) 543 { 544 OUStringBuffer aStrBuf( 128 ); 545 aStrBuf.appendAscii( "intro_" ); 546 aStrBuf.appendAscii( "_" ); 547 aStrBuf.append( _sAppName ); 548 549 OUString aRootIntroFileName = aStrBuf.makeStringAndClear(); 550 551 OUString aBmpFileName = aRootIntroFileName + OUString::createFromAscii( ".png" ); 552 haveBitmap = loadBitmap( path, aBmpFileName ); 553 if ( !haveBitmap ) 554 { 555 aBmpFileName = aRootIntroFileName + OUString::createFromAscii( ".bmp" ); 556 haveBitmap = loadBitmap( path, aBmpFileName ); 557 } 558 } 559 return haveBitmap; 560 } 561 562 void SplashScreen::determineProgressRatioValues( 563 double& rXRelPos, double& rYRelPos, 564 double& rRelWidth, double& rRelHeight ) 565 { 566 sal_Int32 nWidth( 0 ); 567 sal_Int32 nHeight( 0 ); 568 sal_Int32 nScreenRatio( 0 ); 569 570 // determine desktop resolution 571 sal_uInt32 nCount = Application::GetScreenCount(); 572 if ( nCount > 0 ) 573 { 574 // retrieve size from first screen 575 Rectangle aScreenArea = Application::GetScreenPosSizePixel((unsigned int)0); 576 nWidth = aScreenArea.GetWidth(); 577 nHeight = aScreenArea.GetHeight(); 578 nScreenRatio = sal_Int32( math::round( double( nWidth ) / double( nHeight ), 2 ) * 100 ); 579 } 580 581 char szFullScreenProgressRatio[] = "FullScreenProgressRatio0"; 582 char szFullScreenProgressPos[] = "FullScreenProgressPos0"; 583 char szFullScreenProgressSize[] = "FullScreenProgressSize0"; 584 for ( sal_Int32 i = 0; i <= 9; i++ ) 585 { 586 char cNum = '0' + char( i ); 587 szFullScreenProgressRatio[23] = cNum; 588 szFullScreenProgressPos[21] = cNum; 589 szFullScreenProgressSize[22] = cNum; 590 591 OUString sFullScreenProgressRatio = implReadBootstrapKey( 592 OUString::createFromAscii( szFullScreenProgressRatio ) ); 593 594 if ( sFullScreenProgressRatio.getLength() > 0 ) 595 { 596 double fRatio = sFullScreenProgressRatio.toDouble(); 597 sal_Int32 nRatio = sal_Int32( math::round( fRatio, 2 ) * 100 ); 598 if ( nRatio == nScreenRatio ) 599 { 600 OUString sFullScreenProgressPos = implReadBootstrapKey( 601 OUString::createFromAscii( szFullScreenProgressPos ) ); 602 OUString sFullScreenProgressSize = implReadBootstrapKey( 603 OUString::createFromAscii( szFullScreenProgressSize ) ); 604 605 if ( sFullScreenProgressPos.getLength() ) 606 { 607 sal_Int32 idx = 0; 608 double temp = sFullScreenProgressPos.getToken( 0, ',', idx ).toDouble(); 609 if ( idx != -1 ) 610 { 611 rXRelPos = temp; 612 rYRelPos = sFullScreenProgressPos.getToken( 0, ',', idx ).toDouble(); 613 } 614 } 615 616 if ( sFullScreenProgressSize.getLength() ) 617 { 618 sal_Int32 idx = 0; 619 double temp = sFullScreenProgressSize.getToken( 0, ',', idx ).toDouble(); 620 if ( idx != -1 ) 621 { 622 rRelWidth = temp; 623 rRelHeight = sFullScreenProgressSize.getToken( 0, ',', idx ).toDouble(); 624 } 625 } 626 } 627 } 628 else 629 break; 630 } 631 } 632 633 void SplashScreen::Paint( const Rectangle&) 634 { 635 if(!_bVisible) return; 636 637 //native drawing 638 sal_Bool bNativeOK = sal_False; 639 640 // in case of native controls we need to draw directly to the window 641 if( _bNativeProgress && IsNativeControlSupported( CTRL_INTROPROGRESS, PART_ENTIRE_CONTROL ) ) 642 { 643 DrawBitmapEx( Point(), _aIntroBmp ); 644 645 ImplControlValue aValue( _iProgress * _barwidth / _iMax); 646 Rectangle aDrawRect( Point(_tlx, _tly), Size( _barwidth, _barheight ) ); 647 Rectangle aNativeControlRegion, aNativeContentRegion; 648 649 if( GetNativeControlRegion( CTRL_INTROPROGRESS, PART_ENTIRE_CONTROL, aDrawRect, 650 CTRL_STATE_ENABLED, aValue, rtl::OUString(), 651 aNativeControlRegion, aNativeContentRegion ) ) 652 { 653 long nProgressHeight = aNativeControlRegion.GetHeight(); 654 aDrawRect.Top() -= (nProgressHeight - _barheight)/2; 655 aDrawRect.Bottom() += (nProgressHeight - _barheight)/2; 656 } 657 658 if( (bNativeOK = DrawNativeControl( CTRL_INTROPROGRESS, PART_ENTIRE_CONTROL, aDrawRect, 659 CTRL_STATE_ENABLED, aValue, _sProgressText )) != sal_False ) 660 { 661 return; 662 } 663 } 664 //non native drawing 665 // draw bitmap 666 if (_bPaintBitmap) 667 _vdev.DrawBitmapEx( Point(), _aIntroBmp ); 668 669 if (_bPaintProgress) 670 { 671 // draw progress... 672 long length = (_iProgress * _barwidth / _iMax); 673 if (_bShowProgressFrame) 674 length -= (2 * _barspace); 675 if (length < 0) 676 length = 0; 677 678 if (_bShowProgressFrame) 679 { 680 // border 681 _vdev.SetFillColor(); 682 _vdev.SetLineColor( _cProgressFrameColor ); 683 _vdev.DrawRect(Rectangle(_tlx, _tly, _tlx+_barwidth, _tly+_barheight)); 684 _vdev.SetFillColor( _cProgressBarColor ); 685 _vdev.SetLineColor(); 686 _vdev.DrawRect(Rectangle(_tlx+_barspace, _tly+_barspace, _tlx+_barspace+length, _tly+_barheight-_barspace)); 687 _vdev.DrawText( Rectangle(_tlx, _tly+_barheight+5, _tlx+_barwidth, _tly+_barheight+5+20), _sProgressText, TEXT_DRAW_CENTER ); 688 } 689 else 690 { 691 // Show flat progress bar without frame. 692 693 // border 694 _vdev.SetFillColor( _cProgressFrameColor ); 695 _vdev.SetLineColor(); 696 _vdev.DrawRect(Rectangle(_tlx, _tly, _tlx+_barwidth, _tly+_barheight)); 697 698 _vdev.SetFillColor( _cProgressBarColor ); 699 _vdev.SetLineColor(); 700 _vdev.DrawRect(Rectangle(_tlx, _tly, _tlx+length, _tly+_barheight)); 701 } 702 703 _vdev.DrawText( Rectangle(_tlx, _tly+_barheight+5, _tlx+_barwidth, _tly+_barheight+5+20), _sProgressText, TEXT_DRAW_CENTER ); 704 } 705 Size aSize = GetOutputSizePixel(); 706 Size bSize = _vdev.GetOutputSizePixel(); 707 //_vdev.Flush(); 708 //_vdev.DrawOutDev(Point(), GetOutputSize(), Point(), GetOutputSize(), *((IntroWindow*)this) ); 709 DrawOutDev(Point(), GetOutputSizePixel(), Point(), _vdev.GetOutputSizePixel(), _vdev ); 710 //Flush(); 711 } 712 713 714 // get service instance... 715 SplashScreen *SplashScreen::_pINSTANCE = NULL; 716 osl::Mutex SplashScreen::_aMutex; 717 718 Reference< XInterface > SplashScreen::getInstance(const Reference< XMultiServiceFactory >& rSMgr) 719 { 720 if ( _pINSTANCE == 0 ) 721 { 722 osl::MutexGuard guard(_aMutex); 723 if (_pINSTANCE == 0) 724 return (XComponent*)new SplashScreen(rSMgr); 725 } 726 727 return (XComponent*)0; 728 } 729 730 // static service info... 731 const char* SplashScreen::interfaces[] = 732 { 733 "com.sun.star.task.XStartusIndicator", 734 "com.sun.star.lang.XInitialization", 735 NULL, 736 }; 737 const sal_Char *SplashScreen::serviceName = "com.sun.star.office.SplashScreen"; 738 const sal_Char *SplashScreen::implementationName = "com.sun.star.office.comp.SplashScreen"; 739 const sal_Char *SplashScreen::supportedServiceNames[] = {"com.sun.star.office.SplashScreen", NULL}; 740 741 } 742