vcl/source/app/svdata.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: svdata.cxx,v $
  10  * $Revision: 1.56 $
  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_vcl.hxx"
  33 #include <string.h>
  34
  35 #ifndef _SV_SVSYS_HXX
  36 #include <svsys.h>
  37 #endif
  38 #include <vcl/salinst.hxx>
  39 #include <vcl/salframe.hxx>
  40
  41 #ifndef _VOS_MUTEX_HXX
  42 #include <vos/mutex.hxx>
  43 #endif
  44
  45 #include <osl/process.h>
  46 #include <osl/file.hxx>
  47 #include <uno/current_context.hxx>
  48 #include <cppuhelper/implbase1.hxx>
  49 #include <tools/debug.hxx>
  50 #include <vcl/fontcfg.hxx>
  51 #include <vcl/configsettings.hxx>
  52 #include <vcl/svdata.hxx>
  53 #include <vcl/window.h>
  54 #include <vcl/svapp.hxx>
  55 #include <vcl/wrkwin.hxx>
  56 #include <vcl/msgbox.hxx>
  57 #include <vcl/unohelp.hxx>
  58 #include <vcl/button.hxx> // for Button::GetStandardText
  59 #include <vcl/dockwin.hxx>  // for DockingManager
  60 #include <vcl/salimestatus.hxx>
  61 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  62 #include <com/sun/star/awt/XExtendedToolkit.hpp>
  63 #include <com/sun/star/java/JavaNotConfiguredException.hpp>
  64 #include <com/sun/star/java/JavaVMCreationFailureException.hpp>
  65 #include <com/sun/star/java/MissingJavaRuntimeException.hpp>
  66 #include <com/sun/star/java/JavaDisabledException.hpp>
  67
  68 #include <com/sun/star/lang/XComponent.hpp>
  69
  70 #include <stdio.h>
  71 #include <vcl/salsys.hxx>
  72 #include <vcl/svids.hrc>
  73 #include <rtl/instance.hxx>
  74
  75 using namespace com::sun::star::uno;
  76 using namespace com::sun::star::lang;
  77 using namespace com::sun::star::awt;
  78 using namespace rtl;
  79
  80 // =======================================================================
  81
  82 namespace
  83 {
  84     struct private_aImplSVData :
  85         public rtl::Static<ImplSVData, private_aImplSVData> {};
  86 }
  87
  88 // static SV-Data
  89 ImplSVData* pImplSVData = NULL;
  90
  91 SalSystem* ImplGetSalSystem()
  92 {
  93     ImplSVData* pSVData = ImplGetSVData();
  94     if( ! pSVData->mpSalSystem )
  95         pSVData->mpSalSystem = pSVData->mpDefInst->CreateSalSystem();
  96     return pSVData->mpSalSystem;
  97 }
  98
  99
 100 static String& ReplaceJavaErrorMessages( String& rString )
 101 {
 102     rString.SearchAndReplaceAllAscii( "%OK", Button::GetStandardText( BUTTON_OK ) );
 103     rString.SearchAndReplaceAllAscii( "%IGNORE", Button::GetStandardText( BUTTON_IGNORE ) );
 104     rString.SearchAndReplaceAllAscii( "%CANCEL", Button::GetStandardText( BUTTON_CANCEL ) );
 105
 106     return rString;
 107 }
 108
 109 // =======================================================================
 110
 111 void ImplInitSVData()
 112 {
 113     pImplSVData = &private_aImplSVData::get();
 114
 115     // init global instance data
 116     memset( pImplSVData, 0, sizeof( ImplSVData ) );
 117     pImplSVData->maHelpData.mbAutoHelpId = sal_True;
 118     pImplSVData->maHelpData.mbAutoHelpId = sal_True;
 119     pImplSVData->maNWFData.maMenuBarHighlightTextColor = Color( COL_TRANSPARENT );
 120
 121     // find out whether we are running in the testtool
 122     // in this case we need some special workarounds
 123     sal_uInt32 nArgs = osl_getCommandArgCount();
 124     for( sal_uInt32 i = 0; i < nArgs; i++ )
 125     {
 126         rtl::OUString aArg;
 127         osl_getCommandArg( i, &aArg.pData );
 128         if( aArg.equalsAscii( "-enableautomation" ) )
 129         {
 130             pImplSVData->mbIsTestTool = true;
 131             break;
 132         }
 133     }
 134 }
 135
 136 // -----------------------------------------------------------------------
 137
 138 void ImplDeInitSVData()
 139 {
 140     ImplSVData* pSVData = ImplGetSVData();
 141
 142     // delete global instance data
 143     if( pSVData->mpSettingsConfigItem )
 144         delete pSVData->mpSettingsConfigItem;
 145
 146     if( pSVData->mpDockingManager )
 147         delete pSVData->mpDockingManager;
 148
 149     if( pSVData->maGDIData.mpDefaultFontConfiguration )
 150         delete pSVData->maGDIData.mpDefaultFontConfiguration;
 151     if( pSVData->maGDIData.mpFontSubstConfiguration )
 152         delete pSVData->maGDIData.mpFontSubstConfiguration;
 153
 154     if ( pSVData->maAppData.mpMSFTempFileName )
 155     {
 156         if ( pSVData->maAppData.mxMSF.is() )
 157         {
 158             ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > xComp( pSVData->maAppData.mxMSF, ::com::sun::star::uno::UNO_QUERY );
 159             xComp->dispose();
 160             pSVData->maAppData.mxMSF = NULL;
 161         }
 162
 163         ::rtl::OUString aFileUrl;
 164         ::osl::File::getFileURLFromSystemPath( *pSVData->maAppData.mpMSFTempFileName, aFileUrl );
 165         osl::File::remove( aFileUrl );
 166         delete pSVData->maAppData.mpMSFTempFileName;
 167         pSVData->maAppData.mpMSFTempFileName = NULL;
 168     }
 169 }
 170
 171 // -----------------------------------------------------------------------
 172
 173 void ImplDestroySVData()
 174 {
 175     pImplSVData = NULL;
 176 }
 177
 178 // -----------------------------------------------------------------------
 179
 180 Window* ImplGetDefaultWindow()
 181 {
 182     ImplSVData* pSVData = ImplGetSVData();
 183     if ( pSVData->maWinData.mpAppWin )
 184         return pSVData->maWinData.mpAppWin;
 185
 186     // First test if we already have a default window.
 187     // Don't only place a single if..else inside solar mutex lockframe
 188     // because then we might have to wait for the solar mutex what is not neccessary
 189     // if we already have a default window.
 190
 191     if ( !pSVData->mpDefaultWin )
 192     {
 193         Application::GetSolarMutex().acquire();
 194
 195         // Test again because the thread who released the solar mutex could have called
 196         // the same method
 197
 198         if ( !pSVData->mpDefaultWin && !pSVData->mbDeInit )
 199         {
 200             DBG_WARNING( "ImplGetDefaultWindow(): No AppWindow" );
 201             pSVData->mpDefaultWin = new WorkWindow( 0, WB_DEFAULTWIN );
 202             pSVData->mpDefaultWin->SetText( OUString( RTL_CONSTASCII_USTRINGPARAM( "VCL ImplGetDefaultWindow" ) ) );
 203         }
 204         Application::GetSolarMutex().release();
 205     }
 206
 207     return pSVData->mpDefaultWin;
 208 }
 209
 210 // -----------------------------------------------------------------------
 211
 212 #define VCL_CREATERESMGR_NAME( Name )   #Name
 213
 214 ResMgr* ImplGetResMgr()
 215 {
 216     ImplSVData* pSVData = ImplGetSVData();
 217     if ( !pSVData->mpResMgr )
 218     {
 219         ::com::sun::star::lang::Locale aLocale = Application::GetSettings().GetUILocale();
 220         pSVData->mpResMgr = ResMgr::SearchCreateResMgr( VCL_CREATERESMGR_NAME( vcl ), aLocale );
 221
 222         static bool bMessageOnce = false;
 223         if( !pSVData->mpResMgr && ! bMessageOnce )
 224         {
 225             bMessageOnce = true;
 226             const char* pMsg =
 227                 "Missing vcl resource. This indicates that files vital to localization are missing. "
 228                 "You might have a corrupt installation.";
 229             fprintf( stderr, "%s\n", pMsg );
 230             ErrorBox aBox( NULL, WB_OK | WB_DEF_OK, rtl::OUString( pMsg, strlen( pMsg ), RTL_TEXTENCODING_ASCII_US ) );
 231             aBox.Execute();
 232         }
 233     }
 234     return pSVData->mpResMgr;
 235 }
 236
 237 DockingManager* ImplGetDockingManager()
 238 {
 239     ImplSVData* pSVData = ImplGetSVData();
 240     if ( !pSVData->mpDockingManager )
 241         pSVData->mpDockingManager = new DockingManager();
 242
 243     return pSVData->mpDockingManager;
 244 }
 245
 246 class AccessBridgeCurrentContext: public cppu::WeakImplHelper1< com::sun::star::uno::XCurrentContext >
 247 {
 248 public:
 249     AccessBridgeCurrentContext(
 250         const com::sun::star::uno::Reference< com::sun::star::uno::XCurrentContext > &context ) :
 251         m_prevContext( context ) {}
 252
 253     // XCurrentContext
 254     virtual com::sun::star::uno::Any SAL_CALL getValueByName( const rtl::OUString& Name )
 255         throw (com::sun::star::uno::RuntimeException);
 256 private:
 257     com::sun::star::uno::Reference< com::sun::star::uno::XCurrentContext > m_prevContext;
 258 };
 259
 260 com::sun::star::uno::Any AccessBridgeCurrentContext::getValueByName( const rtl::OUString & Name )
 261     throw (com::sun::star::uno::RuntimeException)
 262 {
 263     com::sun::star::uno::Any ret;
 264     if( Name.equalsAscii( "java-vm.interaction-handler" ) )
 265     {
 266         // Currently, for accessbility no interaction handler shall be offered.
 267         // There may be introduced later on a handler using native toolkits
 268         // jbu->obr: Instantiate here your interaction handler
 269     }
 270     else if( m_prevContext.is() )
 271     {
 272         ret = m_prevContext->getValueByName( Name );
 273     }
 274     return ret;
 275 }
 276
 277
 278 bool ImplInitAccessBridge(BOOL bAllowCancel, BOOL &rCancelled)
 279 {
 280     rCancelled = FALSE;
 281
 282     bool bErrorMessage = true;
 283
 284     // Note:
 285     // if bAllowCancel is TRUE we were called from application startup
 286     //  where we will disable any Java errorboxes and show our own accessibility dialog if Java throws an exception
 287     // if bAllowCancel is FALSE we were called from Tools->Options
 288     //  where we will see Java errorboxes, se we do not show our dialogs in addition to Java's
 289
 290     try
 291     {
 292         bool bSuccess = true;
 293
 294         // No error messages when env var is set ..
 295         static const char* pEnv = getenv("SAL_ACCESSIBILITY_ENABLED" );
 296         if( pEnv && *pEnv )
 297         {
 298             bErrorMessage = false;
 299         }
 300
 301         ImplSVData* pSVData = ImplGetSVData();
 302         if( ! pSVData->mxAccessBridge.is() )
 303         {
 304             Reference< XMultiServiceFactory > xFactory(vcl::unohelper::GetMultiServiceFactory());
 305
 306             if( xFactory.is() )
 307             {
 308                 Reference< XExtendedToolkit > xToolkit =
 309                     Reference< XExtendedToolkit >(Application::GetVCLToolkit(), UNO_QUERY);
 310
 311                 Sequence< Any > arguments(1);
 312                 arguments[0] = makeAny(xToolkit);
 313
 314                 // Disable default java error messages on startup, because they were probably unreadable
 315                 // for a disabled user. Use native message boxes which are accessible without java support.
 316                 // No need to do this when activated by Tools-Options dialog ..
 317                 if( bAllowCancel )
 318                 {
 319                     // customize the java-not-available-interaction-handler entry within the
 320                     // current context when called at startup.
 321                     com::sun::star::uno::ContextLayer layer(
 322                         new AccessBridgeCurrentContext( com::sun::star::uno::getCurrentContext() ) );
 323
 324                     pSVData->mxAccessBridge = xFactory->createInstanceWithArguments(
 325                             OUString::createFromAscii( "com.sun.star.accessibility.AccessBridge" ),
 326                             arguments
 327                         );
 328                 }
 329                 else
 330                 {
 331                     pSVData->mxAccessBridge = xFactory->createInstanceWithArguments(
 332                             OUString::createFromAscii( "com.sun.star.accessibility.AccessBridge" ),
 333                             arguments
 334                         );
 335                 }
 336
 337                 if( !pSVData->mxAccessBridge.is() )
 338                     bSuccess = false;
 339             }
 340         }
 341
 342         return bSuccess;
 343     }
 344
 345     catch(::com::sun::star::java::JavaNotConfiguredException e)
 346     {
 347         ResMgr *pResMgr = ImplGetResMgr();
 348         if( bErrorMessage && bAllowCancel && pResMgr )
 349         {
 350             String aTitle(ResId(SV_ACCESSERROR_JAVA_NOT_CONFIGURED, *pResMgr));
 351             String aMessage(ResId(SV_ACCESSERROR_JAVA_MSG, *pResMgr));
 352
 353             aMessage += String(" ", 1, RTL_TEXTENCODING_ASCII_US);
 354             aMessage += String(ResId(SV_ACCESSERROR_OK_CANCEL_MSG, *pResMgr));
 355
 356             int ret = ImplGetSalSystem()->ShowNativeMessageBox(
 357                 aTitle,
 358                 ReplaceJavaErrorMessages(aMessage),
 359                 SALSYSTEM_SHOWNATIVEMSGBOX_BTNCOMBI_OK_CANCEL,
 360                 SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL);
 361
 362             // Do not change the setting in case the user chooses to cancel
 363             if( SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL == ret )
 364                 rCancelled = TRUE;
 365         }
 366
 367         return false;
 368     }
 369
 370     catch(::com::sun::star::java::JavaVMCreationFailureException e)
 371     {
 372         ResMgr *pResMgr = ImplGetResMgr();
 373         if( bErrorMessage && bAllowCancel && pResMgr )
 374         {
 375             String aTitle(ResId(SV_ACCESSERROR_FAULTY_JAVA, *pResMgr));
 376             String aMessage(ResId(SV_ACCESSERROR_JAVA_MSG, *pResMgr));
 377
 378             aMessage += String(" ", 1, RTL_TEXTENCODING_ASCII_US);
 379             aMessage += String(ResId(SV_ACCESSERROR_OK_CANCEL_MSG, *pResMgr));
 380
 381             int ret = ImplGetSalSystem()->ShowNativeMessageBox(
 382                 aTitle,
 383                 ReplaceJavaErrorMessages(aMessage),
 384                 SALSYSTEM_SHOWNATIVEMSGBOX_BTNCOMBI_OK_CANCEL,
 385                 SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL);
 386
 387             // Do not change the setting in case the user chooses to cancel
 388             if( SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL == ret )
 389                 rCancelled = TRUE;
 390         }
 391
 392         return false;
 393     }
 394
 395     catch(::com::sun::star::java::MissingJavaRuntimeException e)
 396     {
 397         ResMgr *pResMgr = ImplGetResMgr();
 398         if( bErrorMessage && bAllowCancel && pResMgr )
 399         {
 400             String aTitle(ResId(SV_ACCESSERROR_MISSING_JAVA, *pResMgr));
 401             String aMessage(ResId(SV_ACCESSERROR_JAVA_MSG, *pResMgr));
 402
 403             aMessage += String(" ", 1, RTL_TEXTENCODING_ASCII_US);
 404             aMessage += String(ResId(SV_ACCESSERROR_OK_CANCEL_MSG, *pResMgr));
 405
 406             int ret = ImplGetSalSystem()->ShowNativeMessageBox(
 407                 aTitle,
 408                 ReplaceJavaErrorMessages(aMessage),
 409                 SALSYSTEM_SHOWNATIVEMSGBOX_BTNCOMBI_OK_CANCEL,
 410                 SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL);
 411
 412             // Do not change the setting in case the user chooses to cancel
 413             if( SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL == ret )
 414                 rCancelled = TRUE;
 415         }
 416
 417         return false;
 418     }
 419
 420     catch(::com::sun::star::java::JavaDisabledException e)
 421     {
 422         ResMgr *pResMgr = ImplGetResMgr();
 423         if( bErrorMessage && bAllowCancel && pResMgr )
 424         {
 425             String aTitle(ResId(SV_ACCESSERROR_JAVA_DISABLED, *pResMgr));
 426             String aMessage(ResId(SV_ACCESSERROR_JAVA_MSG, *pResMgr));
 427
 428             aMessage += String(" ", 1, RTL_TEXTENCODING_ASCII_US);
 429             aMessage += String(ResId(SV_ACCESSERROR_OK_CANCEL_MSG, *pResMgr));
 430
 431             int ret = ImplGetSalSystem()->ShowNativeMessageBox(
 432                 aTitle,
 433                 ReplaceJavaErrorMessages(aMessage),
 434                 SALSYSTEM_SHOWNATIVEMSGBOX_BTNCOMBI_OK_CANCEL,
 435                 SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL);
 436
 437             // Do not change the setting in case the user chooses to cancel
 438             if( SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL == ret )
 439                 rCancelled = TRUE;
 440         }
 441
 442         return false;
 443     }
 444
 445
 446     catch(::com::sun::star::uno::RuntimeException e)
 447     {
 448         ResMgr *pResMgr = ImplGetResMgr();
 449         if( bErrorMessage && pResMgr )
 450         {
 451             String aTitle;
 452             String aMessage(ResId(SV_ACCESSERROR_BRIDGE_MSG, *pResMgr));
 453
 454             if( 0 == e.Message.compareTo(::rtl::OUString::createFromAscii("ClassNotFound"), 13) )
 455             {
 456                 aTitle = String(ResId(SV_ACCESSERROR_MISSING_BRIDGE, *pResMgr));
 457             }
 458             else if( 0 == e.Message.compareTo(::rtl::OUString::createFromAscii("NoSuchMethod"), 12) )
 459             {
 460                 aTitle = String(ResId(SV_ACCESSERROR_WRONG_VERSION, *pResMgr));
 461             }
 462
 463             if( aTitle.Len() != 0 )
 464             {
 465                 if( bAllowCancel )
 466                 {
 467                     // Something went wrong initializing the Java AccessBridge (on Windows) during the
 468                     // startup. Since the office will be probably unusable for a disabled user, we offer
 469                     // to terminate directly.
 470                     aMessage += String(" ", 1, RTL_TEXTENCODING_ASCII_US);
 471                     aMessage += String(ResId(SV_ACCESSERROR_OK_CANCEL_MSG, *pResMgr));
 472
 473                     int ret = ImplGetSalSystem()->ShowNativeMessageBox(
 474                         aTitle,
 475                         ReplaceJavaErrorMessages(aMessage),
 476                         SALSYSTEM_SHOWNATIVEMSGBOX_BTNCOMBI_OK_CANCEL,
 477                         SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL);
 478
 479                     // Do not change the setting in case the user chooses to cancel
 480                     if( SALSYSTEM_SHOWNATIVEMSGBOX_BTN_CANCEL == ret )
 481                         rCancelled = TRUE;
 482                 }
 483                 else
 484                 {
 485                     // The user tried to activate accessibility support using Tools-Options dialog,
 486                     // so we don't offer to terminate here !
 487                     ImplGetSalSystem()->ShowNativeMessageBox(
 488                         aTitle,
 489                         ReplaceJavaErrorMessages(aMessage),
 490                         SALSYSTEM_SHOWNATIVEMSGBOX_BTNCOMBI_OK,
 491                         SALSYSTEM_SHOWNATIVEMSGBOX_BTN_OK);
 492                 }
 493             }
 494         }
 495
 496         return false;
 497     }
 498
 499     catch (...)
 500     {
 501         return false;
 502     }
 503 }
 504
 505 // -----------------------------------------------------------------------
 506
 507 Window* ImplFindWindow( const SalFrame* pFrame, Point& rSalFramePos )
 508 {
 509     ImplSVData* pSVData = ImplGetSVData();
 510     Window*     pFrameWindow = pSVData->maWinData.mpFirstFrame;
 511     while ( pFrameWindow )
 512     {
 513         if ( pFrameWindow->ImplGetFrame() == pFrame )
 514         {
 515             Window* pWindow = pFrameWindow->ImplFindWindow( rSalFramePos );
 516             if ( !pWindow )
 517                 pWindow = pFrameWindow->ImplGetWindow();
 518             rSalFramePos = pWindow->ImplFrameToOutput( rSalFramePos );
 519             return pWindow;
 520         }
 521         pFrameWindow = pFrameWindow->ImplGetFrameData()->mpNextFrame;
 522     }
 523
 524     return NULL;
 525 }