fpicker/source/win32/misc/WinImplHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: WinImplHelper.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_fpicker.hxx"
  33
  34 //------------------------------------------------------------------------
  35 // includes
  36 //------------------------------------------------------------------------
  37 #include <osl/diagnose.h>
  38 #include <rtl/ustrbuf.hxx>
  39 #include "AutoBuffer.hxx"
  40 #include "WinImplHelper.hxx"
  41 #include <com/sun/star/uno/Sequence.hxx>
  42
  43 //------------------------------------------------------------
  44 // namespace directives
  45 //------------------------------------------------------------
  46
  47 using rtl::OUString;
  48 using rtl::OUStringBuffer;
  49 using ::com::sun::star::lang::IllegalArgumentException;
  50 using ::com::sun::star::uno::Reference;
  51 using ::com::sun::star::uno::XInterface;
  52 using ::com::sun::star::uno::Any;
  53 using ::com::sun::star::uno::Sequence;
  54
  55 //------------------------------------------------------------
  56 //
  57 //------------------------------------------------------------
  58
  59 const rtl::OUString TILDE = OUString::createFromAscii( "~" );
  60 const sal_Unicode   TILDE_SIGN = L'~';
  61 const rtl::OUString AMPERSAND = OUString::createFromAscii( "&" );
  62 const sal_Unicode   AMPERSAND_SIGN = L'&';
  63
  64 //------------------------------------------------------------
  65 // OS NAME                      Platform                                        Major   Minor
  66 //
  67 // Windows NT 3.51      VER_PLATFORM_WIN32_NT           3               51
  68 // Windows NT 4.0       VER_PLATFORM_WIN32_NT           4               0
  69 // Windows 2000         VER_PLATFORM_WIN32_NT           5               0
  70 // Windows XP           VER_PLATFORM_WIN32_NT           5               1
  71 // Windows Vista    VER_PLATFORM_WIN32_NT               6               0
  72 // Windows 7            VER_PLATFORM_WIN32_NT           6               1
  73 // Windows 95           VER_PLATFORM_WIN32_WINDOWS      4               0
  74 // Windows 98           VER_PLATFORM_WIN32_WINDOWS      4               10
  75 // Windows ME           VER_PLATFORM_WIN32_WINDOWS      4               90
  76 //------------------------------------------------------------
  77
  78 bool SAL_CALL IsWindowsVersion(unsigned int PlatformId, unsigned int MajorVersion, int MinorVersion = -1)
  79 {
  80     OSVERSIONINFO osvi;
  81     osvi.dwOSVersionInfoSize = sizeof(osvi);
  82
  83     if(!GetVersionEx(&osvi))
  84         return false;
  85
  86     bool bRet = (PlatformId == osvi.dwPlatformId) &&
  87                 (MajorVersion == osvi.dwMajorVersion);
  88
  89     if (MinorVersion > -1)
  90         bRet = bRet &&
  91             (sal::static_int_cast< unsigned int >(MinorVersion) ==
  92              osvi.dwMinorVersion);
  93
  94     return bRet;
  95 }
  96
  97 //------------------------------------------------------------
  98 // determine if we are running under Vista or newer OS
  99 //------------------------------------------------------------
 100
 101 bool SAL_CALL IsWindowsVistaOrNewer()
 102 {
 103     OSVERSIONINFO osvi;
 104     osvi.dwOSVersionInfoSize = sizeof(osvi);
 105
 106     if(!GetVersionEx(&osvi))
 107         return false;
 108
 109     bool bRet = (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId) &&
 110                 (osvi.dwMajorVersion >= 6);
 111
 112     bRet = bRet &&
 113         (osvi.dwMinorVersion >=
 114          sal::static_int_cast< unsigned int >(0));
 115
 116     return bRet;
 117 }
 118
 119 //------------------------------------------------------------
 120 // determine if we are running under Windows 7
 121 //------------------------------------------------------------
 122
 123 bool SAL_CALL IsWindows7()
 124 {
 125     return IsWindowsVersion(VER_PLATFORM_WIN32_NT, 6, 1);
 126 }
 127
 128 //------------------------------------------------------------
 129 // determine if we are running under Windows Vista
 130 //------------------------------------------------------------
 131
 132 bool SAL_CALL IsWindowsVista()
 133 {
 134     return IsWindowsVersion(VER_PLATFORM_WIN32_NT, 6, 0);
 135 }
 136
 137 //------------------------------------------------------------
 138 // determine if we are running under Windows XP
 139 //------------------------------------------------------------
 140
 141 bool SAL_CALL IsWindowsXP()
 142 {
 143     return IsWindowsVersion(VER_PLATFORM_WIN32_NT, 5, 1);
 144 }
 145
 146 //------------------------------------------------------------
 147 // determine if we are running under Windows 2000
 148 //------------------------------------------------------------
 149
 150 bool SAL_CALL IsWindows2000()
 151 {
 152     return IsWindowsVersion(VER_PLATFORM_WIN32_NT, 5, 0);
 153 }
 154
 155 //------------------------------------------------------------
 156 //
 157 //------------------------------------------------------------
 158
 159 bool SAL_CALL IsWindows98()
 160 {
 161     return IsWindowsVersion(VER_PLATFORM_WIN32_WINDOWS, 4, 10);
 162 }
 163
 164 //------------------------------------------------------------
 165 //
 166 //------------------------------------------------------------
 167
 168 bool SAL_CALL IsWindowsME()
 169 {
 170     return      IsWindowsVersion(VER_PLATFORM_WIN32_WINDOWS, 4, 90);
 171 }
 172
 173 //------------------------------------------------------------
 174 //
 175 //------------------------------------------------------------
 176
 177 bool SAL_CALL IsWindows2000Platform()
 178 {
 179     // POST: return true if we are at least on Windows 2000
 180
 181     // WRONG!: return IsWindowsVersion(VER_PLATFORM_WIN32_NT, 5);
 182
 183     OSVERSIONINFO osvi;
 184     ZeroMemory(&osvi, sizeof(osvi));
 185     osvi.dwOSVersionInfoSize = sizeof(osvi);
 186     GetVersionEx(&osvi);
 187     if ( osvi.dwMajorVersion >= 5 )
 188     {
 189         return true;
 190     }
 191     return false;
 192 }
 193
 194 //------------------------------------------------------------
 195 //
 196 //------------------------------------------------------------
 197
 198 void SAL_CALL ListboxAddString( HWND hwnd, const OUString& aString )
 199 {
 200     LRESULT rc = SendMessageW(
 201         hwnd, CB_ADDSTRING, 0, reinterpret_cast< LPARAM >(aString.getStr( )) );
 202     (void) rc; // avoid warning
 203     OSL_ASSERT( (CB_ERR != rc) && (CB_ERRSPACE != rc) );
 204 }
 205
 206 //------------------------------------------------------------
 207 //
 208 //------------------------------------------------------------
 209
 210 OUString SAL_CALL ListboxGetString( HWND hwnd, sal_Int32 aPosition )
 211 {
 212     OSL_ASSERT( IsWindow( hwnd ) );
 213
 214     OUString aString;
 215
 216     LRESULT lItem =
 217         SendMessageW( hwnd, CB_GETLBTEXTLEN, aPosition, 0 );
 218
 219     if ( (CB_ERR != lItem) && (lItem > 0) )
 220     {
 221         // message returns the len of a combobox item
 222         // without trailing '\0' that's why += 1
 223         lItem++;
 224
 225         CAutoUnicodeBuffer aBuff( lItem );
 226
 227         LRESULT lRet =
 228             SendMessageW(
 229                 hwnd, CB_GETLBTEXT, aPosition,
 230                 reinterpret_cast<LPARAM>(&aBuff) );
 231
 232         OSL_ASSERT( lRet != CB_ERR );
 233
 234         if ( CB_ERR != lRet )
 235             aString = OUString( aBuff, lRet );
 236     }
 237
 238     return aString;
 239 }
 240
 241 //------------------------------------------------------------
 242 //
 243 //------------------------------------------------------------
 244
 245 void SAL_CALL ListboxAddItem( HWND hwnd, const Any& aItem, const Reference< XInterface >& rXInterface, sal_Int16 aArgPos )
 246     throw( IllegalArgumentException )
 247 {
 248     OSL_ASSERT( IsWindow( hwnd ) );
 249
 250     if ( !aItem.hasValue( ) ||
 251          aItem.getValueType( ) != getCppuType((OUString*)0) )
 252          throw IllegalArgumentException(
 253             OUString::createFromAscii( "invalid value type or any has no value" ),
 254             rXInterface,
 255             aArgPos );
 256
 257     OUString cbItem;
 258     aItem >>= cbItem;
 259
 260     ListboxAddString( hwnd, cbItem );
 261 }
 262
 263 //------------------------------------------------------------
 264 //
 265 //------------------------------------------------------------
 266
 267 void SAL_CALL ListboxAddItems( HWND hwnd, const Any& aItemList, const Reference< XInterface >& rXInterface, sal_Int16 aArgPos )
 268     throw( IllegalArgumentException )
 269 {
 270     OSL_ASSERT( IsWindow( hwnd ) );
 271
 272     if ( !aItemList.hasValue( ) ||
 273          aItemList.getValueType( ) != getCppuType((Sequence<OUString>*)0) )
 274          throw IllegalArgumentException(
 275             OUString::createFromAscii( "invalid value type or any has no value" ),
 276             rXInterface,
 277             aArgPos );
 278
 279     Sequence< OUString > aStringList;
 280     aItemList >>= aStringList;
 281
 282     sal_Int32 nItemCount = aStringList.getLength( );
 283     for( sal_Int32 i = 0; i < nItemCount; i++ )
 284     {
 285         ListboxAddString( hwnd, aStringList[i] );
 286     }
 287 }
 288
 289 //------------------------------------------------------------
 290 //
 291 //------------------------------------------------------------
 292
 293 void SAL_CALL ListboxDeleteItem( HWND hwnd, const Any& aPosition, const Reference< XInterface >& rXInterface, sal_Int16 aArgPos )
 294     throw( IllegalArgumentException )
 295 {
 296     OSL_ASSERT( IsWindow( hwnd ) );
 297
 298     if ( !aPosition.hasValue( ) ||
 299          ( (aPosition.getValueType( ) != getCppuType((sal_Int32*)0)) &&
 300            (aPosition.getValueType( ) != getCppuType((sal_Int16*)0)) &&
 301            (aPosition.getValueType( ) != getCppuType((sal_Int8*)0)) ) )
 302          throw IllegalArgumentException(
 303             OUString::createFromAscii( "invalid value type or any has no value" ),
 304             rXInterface,
 305             aArgPos );
 306
 307     sal_Int32 nPos;
 308     aPosition >>= nPos;
 309
 310     LRESULT lRet = SendMessage( hwnd, CB_DELETESTRING, nPos, 0 );
 311
 312     // if the return value is CB_ERR the given
 313     // index was not correct
 314     if ( CB_ERR == lRet )
 315         throw IllegalArgumentException(
 316             OUString::createFromAscii( "inavlid item position" ),
 317             rXInterface,
 318             aArgPos );
 319 }
 320
 321 //------------------------------------------------------------
 322 //
 323 //------------------------------------------------------------
 324
 325 void SAL_CALL ListboxDeleteItems( HWND hwnd, const Any&, const Reference< XInterface >&, sal_Int16 )
 326     throw( IllegalArgumentException )
 327 {
 328     OSL_ASSERT( IsWindow( hwnd ) );
 329
 330     LRESULT lRet = 0;
 331
 332     do
 333     {
 334         // the return value on success is the number
 335         // of remaining elements in the listbox
 336         lRet = SendMessageW( hwnd, CB_DELETESTRING, 0, 0 );
 337     }
 338     while ( (lRet != CB_ERR) && (lRet > 0) );
 339 }
 340
 341 //------------------------------------------------------------
 342 //
 343 //------------------------------------------------------------
 344
 345 void SAL_CALL ListboxSetSelectedItem( HWND hwnd, const Any& aPosition, const Reference< XInterface >& rXInterface, sal_Int16 aArgPos )
 346     throw( IllegalArgumentException )
 347 {
 348     OSL_ASSERT( IsWindow( hwnd ) );
 349
 350      if ( !aPosition.hasValue( ) ||
 351          ( (aPosition.getValueType( ) != getCppuType((sal_Int32*)0)) &&
 352            (aPosition.getValueType( ) != getCppuType((sal_Int16*)0)) &&
 353            (aPosition.getValueType( ) != getCppuType((sal_Int8*)0)) ) )
 354          throw IllegalArgumentException(
 355             OUString::createFromAscii( "invalid value type or any has no value" ),
 356             rXInterface,
 357             aArgPos );
 358
 359     sal_Int32 nPos;
 360     aPosition >>= nPos;
 361
 362     if ( nPos < -1 )
 363         throw IllegalArgumentException(
 364             OUString::createFromAscii("invalid index"),
 365             rXInterface,
 366             aArgPos );
 367
 368     LRESULT lRet = SendMessageW( hwnd, CB_SETCURSEL, nPos, 0 );
 369
 370     if ( (CB_ERR == lRet) && (-1 != nPos) )
 371         throw IllegalArgumentException(
 372             OUString::createFromAscii("invalid index"),
 373             rXInterface,
 374             aArgPos );
 375 }
 376
 377 //------------------------------------------------------------
 378 //
 379 //------------------------------------------------------------
 380
 381 Any SAL_CALL ListboxGetItems( HWND hwnd )
 382 {
 383     OSL_ASSERT( IsWindow( hwnd ) );
 384
 385     LRESULT nItemCount = SendMessageW( hwnd, CB_GETCOUNT, 0, 0 );
 386
 387     Sequence< OUString > aItemList;
 388
 389     if ( CB_ERR != nItemCount )
 390     {
 391         aItemList.realloc( nItemCount );
 392
 393         for ( sal_Int32 i = 0; i < nItemCount; i++ )
 394         {
 395             aItemList[i] = ListboxGetString( hwnd, i );
 396         }
 397     }
 398
 399     Any aAny;
 400     aAny <<= aItemList;
 401
 402     return aAny;
 403 }
 404
 405 //------------------------------------------------------------
 406 //
 407 //------------------------------------------------------------
 408
 409 Any SAL_CALL ListboxGetSelectedItem( HWND hwnd )
 410 {
 411     OSL_ASSERT( IsWindow( hwnd ) );
 412
 413     LRESULT idxItem = SendMessageW( hwnd, CB_GETCURSEL, 0, 0 );
 414
 415     Any aAny;
 416     aAny <<= ListboxGetString( hwnd, idxItem );
 417
 418     return aAny;
 419 }
 420
 421 //------------------------------------------------------------
 422 //
 423 //------------------------------------------------------------
 424
 425 Any SAL_CALL ListboxGetSelectedItemIndex( HWND hwnd )
 426 {
 427     OSL_ASSERT( IsWindow( hwnd ) );
 428
 429     LRESULT idxItem = SendMessageW( hwnd, CB_GETCURSEL, 0, 0 );
 430
 431     Any aAny;
 432     aAny <<= static_cast< sal_Int32 >( idxItem );
 433
 434     return aAny;
 435 }
 436
 437 //------------------------------------------------------------
 438 //
 439 //------------------------------------------------------------
 440
 441 Any SAL_CALL CheckboxGetState( HWND hwnd )
 442 {
 443     OSL_ASSERT( IsWindow( hwnd ) );
 444
 445     LRESULT lChkState = SendMessageW( hwnd, BM_GETCHECK, 0, 0 );
 446     sal_Bool bChkState = (lChkState == BST_CHECKED) ? sal_True : sal_False;
 447     Any aAny;
 448     aAny.setValue( &bChkState, getCppuType((sal_Bool*)0) );
 449     return aAny;
 450 }
 451
 452 //------------------------------------------------------------
 453 //
 454 //------------------------------------------------------------
 455
 456 void SAL_CALL CheckboxSetState(
 457     HWND hwnd, const ::com::sun::star::uno::Any& aState, const Reference< XInterface >& rXInterface, sal_Int16 aArgPos )
 458     throw( IllegalArgumentException )
 459 {
 460     OSL_ASSERT( IsWindow( hwnd ) );
 461
 462     if ( !aState.hasValue( ) ||
 463          aState.getValueType( ) != getCppuType((sal_Bool*)0) )
 464          throw IllegalArgumentException(
 465             OUString::createFromAscii( "invalid value type or any has no value" ),
 466             rXInterface,
 467             aArgPos );
 468
 469     sal_Bool bCheckState = *reinterpret_cast< const sal_Bool* >( aState.getValue( ) );
 470     WPARAM wParam = bCheckState ? BST_CHECKED : BST_UNCHECKED;
 471     SendMessageW( hwnd, BM_SETCHECK, wParam, 0 );
 472 }
 473
 474 //------------------------------------------------------------
 475 //
 476 //------------------------------------------------------------
 477
 478 sal_uInt32 SAL_CALL _wcslenex( const sal_Unicode* pStr )
 479 {
 480     if ( !pStr )
 481         return 0;
 482
 483     const sal_Unicode* pTemp = pStr;
 484     sal_uInt32 strLen = 0;
 485     while( *pTemp || *(pTemp + 1) )
 486     {
 487         pTemp++;
 488         strLen++;
 489     }
 490
 491     return strLen;
 492 }
 493
 494 //------------------------------------------------------------
 495 //
 496 //------------------------------------------------------------
 497
 498 void Replace( const OUString& aLabel, sal_Unicode OldChar, sal_Unicode NewChar, OUStringBuffer& aBuffer )
 499 {
 500     OSL_ASSERT( aLabel.getLength( ) );
 501     OSL_ASSERT( aBuffer.getCapacity( ) >= (aLabel.getLength( )) );
 502
 503     sal_Int32 i = 0;
 504     const sal_Unicode* pCurrent  = aLabel.getStr( );
 505     const sal_Unicode* pNext     = aLabel.getStr( ) + 1;
 506     const sal_Unicode* pEnd      = aLabel.getStr( ) + aLabel.getLength( );
 507
 508     while( pCurrent < pEnd )
 509     {
 510         OSL_ASSERT( pNext <= pEnd );
 511         OSL_ASSERT( (i >= 0) && (i < aBuffer.getCapacity( )) );
 512
 513         if ( OldChar == *pCurrent )
 514         {
 515             if ( OldChar == *pNext )
 516             {
 517                 // two OldChars in line will
 518                 // be replaced by one
 519                 // e.g. ~~ -> ~
 520                 aBuffer.insert( i, *pCurrent );
 521
 522                 // skip the next one
 523                 pCurrent++;
 524                 pNext++;
 525             }
 526             else
 527             {
 528                 // one OldChar will be replace
 529                 // by NexChar
 530                 aBuffer.insert( i, NewChar );
 531             }
 532          }
 533          else if ( *pCurrent == NewChar )
 534          {
 535             // a NewChar will be replaced by
 536              // two NewChars
 537              // e.g. & -> &&
 538             aBuffer.insert( i++, *pCurrent );
 539             aBuffer.insert( i, *pCurrent );
 540          }
 541          else
 542          {
 543             aBuffer.insert( i, *pCurrent );
 544          }
 545
 546          pCurrent++;
 547          pNext++;
 548          i++;
 549     }
 550 }
 551
 552 //------------------------------------------------------------
 553 // converts a soffice label to a windows label
 554 // the following rules for character replacements
 555 // will be done:
 556 // '~'  -> '&'
 557 // '~~' -> '~'
 558 // '&'  -> '&&'
 559 //------------------------------------------------------------
 560
 561 OUString SOfficeToWindowsLabel( const rtl::OUString& aSOLabel )
 562 {
 563     OUString aWinLabel = aSOLabel;
 564
 565     if ( (aWinLabel.indexOf( TILDE ) > -1) || (aWinLabel.indexOf( AMPERSAND ) > -1) )
 566     {
 567         sal_Int32 nStrLen = aWinLabel.getLength( );
 568
 569         // in the worst case the new string is
 570         // doubled in length, maybe some waste
 571         // of memory but how long is a label
 572         // normaly(?)
 573         rtl::OUStringBuffer aBuffer( nStrLen * 2 );
 574
 575         Replace( aWinLabel, TILDE_SIGN, AMPERSAND_SIGN, aBuffer );
 576
 577         aWinLabel = aBuffer.makeStringAndClear( );
 578     }
 579
 580     return aWinLabel;
 581 }
 582
 583 //------------------------------------------------------------
 584 // converts a windows label to a soffice label
 585 // the following rules for character replacements
 586 // will be done:
 587 // '&'  -> '~'
 588 // '&&' -> '&'
 589 // '~'  -> '~~'
 590 //------------------------------------------------------------
 591
 592 OUString WindowsToSOfficeLabel( const rtl::OUString& aWinLabel )
 593 {
 594     OUString aSOLabel = aWinLabel;
 595
 596     if ( (aSOLabel.indexOf( TILDE ) > -1) || (aSOLabel.indexOf( AMPERSAND ) > -1) )
 597     {
 598         sal_Int32 nStrLen = aSOLabel.getLength( );
 599
 600         // in the worst case the new string is
 601         // doubled in length, maybe some waste
 602         // of memory but how long is a label
 603         // normaly(?)
 604         rtl::OUStringBuffer aBuffer( nStrLen * 2 );
 605
 606         Replace( aSOLabel, AMPERSAND_SIGN, TILDE_SIGN, aBuffer );
 607
 608         aSOLabel = aBuffer.makeStringAndClear( );
 609     }
 610
 611     return aSOLabel;
 612 }
 613