| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_extensions.hxx" |
| |
| #include "updatehdl.hxx" |
| #include "update.hrc" |
| |
| #include "osl/diagnose.h" |
| #include "osl/thread.hxx" |
| #include "osl/file.hxx" |
| #include "rtl/ustring.hxx" |
| #include "rtl/bootstrap.hxx" |
| |
| #include "com/sun/star/uno/Sequence.h" |
| |
| #include <com/sun/star/style/VerticalAlignment.hpp> |
| |
| #include "com/sun/star/awt/ActionEvent.hpp" |
| #include "com/sun/star/awt/PushButtonType.hpp" |
| #include "com/sun/star/awt/VclWindowPeerAttribute.hpp" |
| #include "com/sun/star/awt/WindowAttribute.hpp" |
| #include "com/sun/star/awt/XButton.hpp" |
| #include "com/sun/star/awt/XControl.hpp" |
| #include "com/sun/star/awt/XControlContainer.hpp" |
| #include "com/sun/star/awt/XMessageBox.hpp" |
| #include "com/sun/star/awt/XAnimation.hpp" |
| #include "com/sun/star/awt/XTopWindow.hpp" |
| #include "com/sun/star/awt/XVclWindowPeer.hpp" |
| #include "com/sun/star/awt/XVclContainer.hpp" |
| #include "com/sun/star/awt/XWindow.hpp" |
| #include "com/sun/star/awt/XWindow2.hpp" |
| |
| #include <com/sun/star/beans/PropertyValue.hpp> |
| #include "com/sun/star/beans/XPropertySet.hpp" |
| |
| #include "com/sun/star/container/XNameContainer.hpp" |
| |
| #include "com/sun/star/frame/XDesktop.hpp" |
| |
| #include "com/sun/star/lang/XMultiServiceFactory.hpp" |
| #include "com/sun/star/task/InteractionRequestStringResolver.hpp" |
| |
| #include <com/sun/star/resource/XResourceBundleLoader.hpp> |
| |
| #include "updatehdl.hrc" |
| #include <tools/urlobj.hxx> |
| |
| #define UNISTRING(s) rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(s)) |
| |
| #define COMMAND_CLOSE UNISTRING("close") |
| |
| #define CTRL_THROBBER UNISTRING("throbber") |
| #define CTRL_PROGRESS UNISTRING("progress") |
| |
| #define TEXT_STATUS UNISTRING("text_status") |
| #define TEXT_PERCENT UNISTRING("text_percent") |
| #define TEXT_DESCRIPTION UNISTRING("text_description") |
| |
| #define FIXED_LINE_MODEL UNISTRING("com.sun.star.awt.UnoControlFixedLineModel") |
| #define FIXED_TEXT_MODEL UNISTRING("com.sun.star.awt.UnoControlFixedTextModel") |
| #define EDIT_FIELD_MODEL UNISTRING("com.sun.star.awt.UnoControlEditModel") |
| #define BUTTON_MODEL UNISTRING("com.sun.star.awt.UnoControlButtonModel") |
| #define GROUP_BOX_MODEL UNISTRING("com.sun.star.awt.UnoControlGroupBoxModel") |
| |
| using namespace com::sun::star; |
| |
| //-------------------------------------------------------------------- |
| UpdateHandler::UpdateHandler( const uno::Reference< uno::XComponentContext > & rxContext, |
| const rtl::Reference< IActionListener > & rxActionListener ) : |
| mxContext( rxContext ), |
| mxActionListener( rxActionListener ), |
| meCurState( UPDATESTATES_COUNT ), |
| meLastState( UPDATESTATES_COUNT ), |
| mnPercent( 0 ), |
| mnLastCtrlState( -1 ), |
| mbDownloadBtnHasDots( false ), |
| mbVisible( false ), |
| mbStringsLoaded( false ), |
| mbMinimized( false ), |
| mbListenerAdded(false), |
| mbShowsMessageBox(false) |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| UpdateHandler::~UpdateHandler() |
| { |
| mxContext = NULL; |
| mxUpdDlg = NULL; |
| mxInteractionHdl = NULL; |
| mxActionListener = NULL; |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::enableControls( short nCtrlState ) |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| if ( nCtrlState == mnLastCtrlState ) |
| return; |
| |
| bool bEnableControl; |
| |
| short nCurStateVal = nCtrlState; |
| short nOldStateVal = mnLastCtrlState; |
| |
| // the help button should always be the last button in the |
| // enum list und must never be disabled |
| for ( int i=0; i<HELP_BUTTON; i++ ) |
| { |
| nCurStateVal = (short)(nCtrlState >> i); |
| nOldStateVal = (short)(mnLastCtrlState >> i); |
| if ( ( nCurStateVal & 0x01 ) != ( nOldStateVal & 0x01 ) ) |
| { |
| bEnableControl = ( ( nCurStateVal & 0x01 ) == 0x01 ); |
| setControlProperty( msButtonIDs[i], UNISTRING("Enabled"), uno::Any( bEnableControl ) ); |
| } |
| } |
| |
| mnLastCtrlState = nCtrlState; |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::setDownloadBtnLabel( bool bAppendDots ) |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| if ( mbDownloadBtnHasDots != bAppendDots ) |
| { |
| rtl::OUString aLabel( msDownload ); |
| |
| if ( bAppendDots ) |
| aLabel += UNISTRING( "..." ); |
| |
| setControlProperty( msButtonIDs[DOWNLOAD_BUTTON], UNISTRING("Label"), uno::Any( aLabel ) ); |
| setControlProperty( msButtonIDs[DOWNLOAD_BUTTON], UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_DOWNLOAD2 ) ) ); |
| |
| mbDownloadBtnHasDots = bAppendDots; |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::setState( UpdateState eState ) |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| meCurState = eState; |
| |
| if ( mxUpdDlg.is() && mbVisible ) |
| updateState( meCurState ); |
| } |
| |
| //-------------------------------------------------------------------- |
| bool UpdateHandler::isVisible() const |
| { |
| if ( !mxUpdDlg.is() ) return false; |
| |
| uno::Reference< awt::XWindow2 > xWindow( mxUpdDlg, uno::UNO_QUERY ); |
| |
| if ( xWindow.is() ) |
| return xWindow->isVisible(); |
| else |
| return false; |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::setVisible( bool bVisible ) |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| mbVisible = bVisible; |
| |
| if ( bVisible ) |
| { |
| if ( !mxUpdDlg.is() ) |
| createDialog(); |
| |
| // this should never happen, but if it happens we better return here |
| if ( !mxUpdDlg.is() ) |
| return; |
| |
| updateState( meCurState ); |
| |
| uno::Reference< awt::XWindow > xWindow( mxUpdDlg, uno::UNO_QUERY ); |
| |
| if ( xWindow.is() ) |
| xWindow->setVisible( bVisible ); |
| |
| uno::Reference< awt::XTopWindow > xTopWindow( mxUpdDlg, uno::UNO_QUERY ); |
| if ( xTopWindow.is() ) |
| { |
| xTopWindow->toFront(); |
| if ( !mbListenerAdded ) |
| { |
| xTopWindow->addTopWindowListener( this ); |
| mbListenerAdded = true; |
| } |
| } |
| } |
| else if ( mxUpdDlg.is() ) |
| { |
| uno::Reference< awt::XWindow > xWindow( mxUpdDlg, uno::UNO_QUERY ); |
| |
| if ( xWindow.is() ) |
| xWindow->setVisible( bVisible ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::setProgress( sal_Int32 nPercent ) |
| { |
| if ( nPercent > 100 ) |
| nPercent = 100; |
| else if ( nPercent < 0 ) |
| nPercent = 0; |
| |
| if ( nPercent != mnPercent ) |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| mnPercent = nPercent; |
| setControlProperty( CTRL_PROGRESS, UNISTRING("ProgressValue"), uno::Any( nPercent ) ); |
| setControlProperty( TEXT_PERCENT, UNISTRING("Text"), uno::Any( substVariables(msPercent) ) ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::setErrorMessage( const rtl::OUString& rErrorMsg ) |
| { |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( rErrorMsg ) ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::setDownloadFile( const rtl::OUString& rFilePath ) |
| { |
| sal_Int32 nLast = rFilePath.lastIndexOf( '/' ); |
| if ( nLast != -1 ) |
| { |
| msDownloadFile = rFilePath.copy( nLast+1 ); |
| const rtl::OUString aDownloadURL = rFilePath.copy( 0, nLast ); |
| osl::FileBase::getSystemPathFromFileURL( aDownloadURL, msDownloadPath ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| rtl::OUString UpdateHandler::getBubbleText( UpdateState eState ) |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| rtl::OUString sText; |
| sal_Int32 nIndex = (sal_Int32) eState; |
| |
| loadStrings(); |
| |
| if ( ( UPDATESTATE_UPDATE_AVAIL <= nIndex ) && ( nIndex < UPDATESTATES_COUNT ) ) |
| sText = substVariables( msBubbleTexts[ nIndex - UPDATESTATE_UPDATE_AVAIL ] ); |
| |
| return sText; |
| } |
| |
| //-------------------------------------------------------------------- |
| rtl::OUString UpdateHandler::getBubbleTitle( UpdateState eState ) |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| rtl::OUString sText; |
| sal_Int32 nIndex = (sal_Int32) eState; |
| |
| loadStrings(); |
| |
| if ( ( UPDATESTATE_UPDATE_AVAIL <= nIndex ) && ( nIndex < UPDATESTATES_COUNT ) ) |
| sText = substVariables( msBubbleTitles[ nIndex - UPDATESTATE_UPDATE_AVAIL] ); |
| |
| return sText; |
| } |
| |
| //-------------------------------------------------------------------- |
| rtl::OUString UpdateHandler::getDefaultInstErrMsg() |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| loadStrings(); |
| |
| return substVariables( msInstallError ); |
| } |
| |
| // XActionListener |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::disposing( const lang::EventObject& rEvt ) |
| throw( uno::RuntimeException ) |
| { |
| if ( rEvt.Source == mxUpdDlg ) |
| mxUpdDlg.clear(); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::actionPerformed( awt::ActionEvent const & rEvent ) |
| throw( uno::RuntimeException ) |
| { |
| DialogControls eButton = BUTTON_COUNT; |
| for ( int i = 0; i < BUTTON_COUNT; i++ ) |
| { |
| if ( rEvent.ActionCommand.equals( msButtonIDs[i] ) ) |
| { |
| eButton = (DialogControls) i; |
| break; |
| } |
| } |
| |
| if ( rEvent.ActionCommand.equals( COMMAND_CLOSE ) ) |
| { |
| if ( ( mnLastCtrlState & ( 1 << CLOSE_BUTTON ) ) == ( 1 << CLOSE_BUTTON ) ) |
| eButton = CLOSE_BUTTON; |
| else |
| eButton = CANCEL_BUTTON; |
| } |
| |
| switch ( eButton ) { |
| case CANCEL_BUTTON: |
| { |
| bool bCancel = true; |
| |
| if ( ( meCurState == UPDATESTATE_DOWNLOADING ) || |
| ( meCurState == UPDATESTATE_DOWNLOAD_PAUSED ) || |
| ( meCurState == UPDATESTATE_ERROR_DOWNLOADING ) ) |
| bCancel = showWarning( msCancelMessage ); |
| |
| if ( bCancel ) |
| { |
| mxActionListener->cancel(); |
| setVisible( false ); |
| } |
| break; |
| } |
| case CLOSE_BUTTON: |
| setVisible( false ); |
| if ( meCurState == UPDATESTATE_ERROR_CHECKING ) |
| mxActionListener->closeAfterFailure(); |
| break; |
| case DOWNLOAD_BUTTON: |
| mxActionListener->download(); |
| break; |
| case INSTALL_BUTTON: |
| if ( showWarning( msInstallMessage ) ) |
| mxActionListener->install(); |
| break; |
| case PAUSE_BUTTON: |
| mxActionListener->pause(); |
| break; |
| case RESUME_BUTTON: |
| mxActionListener->resume(); |
| break; |
| case HELP_BUTTON: |
| break; |
| default: |
| OSL_ENSURE( false, "UpdateHandler::actionPerformed: unknown command!" ); |
| } |
| } |
| |
| // XTopWindowListener |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::windowOpened( const lang::EventObject& ) |
| throw( uno::RuntimeException ) |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::windowClosing( const lang::EventObject& e ) |
| throw( uno::RuntimeException ) |
| { |
| awt::ActionEvent aActionEvt; |
| aActionEvt.ActionCommand = COMMAND_CLOSE; |
| aActionEvt.Source = e.Source; |
| |
| actionPerformed( aActionEvt ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::windowClosed( const lang::EventObject& ) |
| throw( uno::RuntimeException ) |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::windowMinimized( const lang::EventObject& ) |
| throw( uno::RuntimeException ) |
| { |
| mbMinimized = true; |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::windowNormalized( const lang::EventObject& ) |
| throw( uno::RuntimeException ) |
| { |
| mbMinimized = false; |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::windowActivated( const lang::EventObject& ) |
| throw( uno::RuntimeException ) |
| { |
| } |
| |
| //-------------------------------------------------------------------- |
| void SAL_CALL UpdateHandler::windowDeactivated( const lang::EventObject& ) |
| throw( uno::RuntimeException ) |
| { |
| } |
| |
| // XInteractionHandler |
| //------------------------------------------------------------------------------ |
| void SAL_CALL UpdateHandler::handle( uno::Reference< task::XInteractionRequest > const & rRequest) |
| throw (uno::RuntimeException) |
| { |
| if ( !mxInteractionHdl.is() ) |
| { |
| if( !mxContext.is() ) |
| throw uno::RuntimeException( UNISTRING( "UpdateHandler:: empty component context" ), *this ); |
| |
| uno::Reference< lang::XMultiComponentFactory > xServiceManager(mxContext->getServiceManager()); |
| |
| if( !xServiceManager.is() ) |
| throw uno::RuntimeException( UNISTRING( "UpdateHandler: unable to obtain service manager from component context" ), *this ); |
| |
| mxInteractionHdl = uno::Reference<task::XInteractionHandler> ( |
| xServiceManager->createInstanceWithContext( |
| UNISTRING( "com.sun.star.task.InteractionHandler" ), |
| mxContext), |
| uno::UNO_QUERY_THROW); |
| if( !mxInteractionHdl.is() ) |
| throw uno::RuntimeException( UNISTRING( "UpdateHandler:: could not get default interaction handler" ), *this ); |
| } |
| uno::Reference< task::XInteractionRequestStringResolver > xStrResolver = |
| task::InteractionRequestStringResolver::create( mxContext ); |
| beans::Optional< ::rtl::OUString > aErrorText = xStrResolver->getStringFromInformationalRequest( rRequest ); |
| if ( aErrorText.IsPresent ) |
| { |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( aErrorText.Value ) ); |
| |
| uno::Sequence< uno::Reference< task::XInteractionContinuation > > xContinuations = rRequest->getContinuations(); |
| if ( xContinuations.getLength() == 1 ) |
| { |
| if ( meCurState == UPDATESTATE_CHECKING ) |
| setState( UPDATESTATE_ERROR_CHECKING ); |
| else if ( meCurState == UPDATESTATE_DOWNLOADING ) |
| setState( UPDATESTATE_ERROR_DOWNLOADING ); |
| |
| xContinuations[0]->select(); |
| } |
| else |
| mxInteractionHdl->handle( rRequest ); |
| } |
| else |
| mxInteractionHdl->handle( rRequest ); |
| } |
| |
| //------------------------------------------------------------------------------ |
| // XTerminateListener |
| //------------------------------------------------------------------------------ |
| void SAL_CALL UpdateHandler::queryTermination( const lang::EventObject& ) |
| throw ( frame::TerminationVetoException, uno::RuntimeException ) |
| { |
| if ( mbShowsMessageBox ) |
| { |
| uno::Reference< awt::XTopWindow > xTopWindow( mxUpdDlg, uno::UNO_QUERY ); |
| if ( xTopWindow.is() ) |
| xTopWindow->toFront(); |
| |
| throw frame::TerminationVetoException( |
| UNISTRING("The office cannot be closed while displaying a warning!"), |
| uno::Reference<XInterface>(static_cast<frame::XTerminateListener*>(this), uno::UNO_QUERY)); |
| } |
| else |
| setVisible( false ); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void SAL_CALL UpdateHandler::notifyTermination( const lang::EventObject& ) |
| throw ( uno::RuntimeException ) |
| { |
| osl::MutexGuard aGuard( maMutex ); |
| |
| if ( mxUpdDlg.is() ) |
| { |
| uno::Reference< awt::XTopWindow > xTopWindow( mxUpdDlg, uno::UNO_QUERY ); |
| if ( xTopWindow.is() ) |
| xTopWindow->removeTopWindowListener( this ); |
| |
| uno::Reference< lang::XComponent > xComponent( mxUpdDlg, uno::UNO_QUERY ); |
| if ( xComponent.is() ) |
| xComponent->dispose(); |
| |
| mxUpdDlg.clear(); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| //-------------------------------------------------------------------- |
| //-------------------------------------------------------------------- |
| void UpdateHandler::updateState( UpdateState eState ) |
| { |
| if ( meLastState == eState ) |
| return; |
| |
| if ( isVisible() ) |
| {} // ToTop(); |
| |
| rtl::OUString sText; |
| |
| switch ( eState ) |
| { |
| case UPDATESTATE_CHECKING: |
| showControls( (1<<CANCEL_BUTTON) + (1<<THROBBER_CTRL) ); |
| enableControls( 1<<CANCEL_BUTTON ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msChecking) ) ); |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( rtl::OUString() ) ); |
| focusControl( CANCEL_BUTTON ); |
| break; |
| case UPDATESTATE_ERROR_CHECKING: |
| showControls( 0 ); |
| enableControls( 1 << CLOSE_BUTTON ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msCheckingError) ) ); |
| focusControl( CLOSE_BUTTON ); |
| break; |
| case UPDATESTATE_UPDATE_AVAIL: |
| showControls( 0 ); |
| enableControls( ( 1 << CLOSE_BUTTON ) + ( 1 << DOWNLOAD_BUTTON ) ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msUpdFound) ) ); |
| |
| sText = substVariables(msDownloadWarning); |
| if ( msDescriptionMsg.getLength() ) |
| sText += UNISTRING("\n\n") + msDescriptionMsg; |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( sText ) ); |
| |
| setDownloadBtnLabel( false ); |
| focusControl( DOWNLOAD_BUTTON ); |
| break; |
| case UPDATESTATE_UPDATE_NO_DOWNLOAD: |
| showControls( 0 ); |
| enableControls( ( 1 << CLOSE_BUTTON ) + ( 1 << DOWNLOAD_BUTTON ) ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msUpdFound) ) ); |
| |
| sText = substVariables(msDownloadNotAvail); |
| if ( msDescriptionMsg.getLength() ) |
| sText += UNISTRING("\n\n") + msDescriptionMsg; |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( sText ) ); |
| |
| setDownloadBtnLabel( true ); |
| focusControl( DOWNLOAD_BUTTON ); |
| break; |
| case UPDATESTATE_NO_UPDATE_AVAIL: |
| case UPDATESTATE_EXT_UPD_AVAIL: // will only be set, when there are no office updates avail |
| showControls( 0 ); |
| enableControls( 1 << CLOSE_BUTTON ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msNoUpdFound) ) ); |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( rtl::OUString() ) ); |
| focusControl( CLOSE_BUTTON ); |
| break; |
| case UPDATESTATE_DOWNLOADING: |
| showControls( (1<<PROGRESS_CTRL) + (1<<CANCEL_BUTTON) + (1<<PAUSE_BUTTON) + (1<<RESUME_BUTTON) ); |
| enableControls( (1<<CLOSE_BUTTON) + (1<<CANCEL_BUTTON) + (1<<PAUSE_BUTTON) ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msDownloading) ) ); |
| setControlProperty( TEXT_PERCENT, UNISTRING("Text"), uno::Any( substVariables(msPercent) ) ); |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( substVariables(msDownloadWarning) ) ); |
| setControlProperty( CTRL_PROGRESS, UNISTRING("ProgressValue"), uno::Any( mnPercent ) ); |
| focusControl( CLOSE_BUTTON ); |
| break; |
| case UPDATESTATE_DOWNLOAD_PAUSED: |
| showControls( (1<<PROGRESS_CTRL) + (1<<CANCEL_BUTTON) + (1<<PAUSE_BUTTON) + (1<<RESUME_BUTTON) ); |
| enableControls( (1<<CLOSE_BUTTON) + (1<<CANCEL_BUTTON) + (1<<RESUME_BUTTON) ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msDownloadPause) ) ); |
| setControlProperty( TEXT_PERCENT, UNISTRING("Text"), uno::Any( substVariables(msPercent) ) ); |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( substVariables(msDownloadWarning) ) ); |
| setControlProperty( CTRL_PROGRESS, UNISTRING("ProgressValue"), uno::Any( mnPercent ) ); |
| focusControl( CLOSE_BUTTON ); |
| break; |
| case UPDATESTATE_ERROR_DOWNLOADING: |
| showControls( (1<<PROGRESS_CTRL) + (1<<CANCEL_BUTTON) + (1<<PAUSE_BUTTON) + (1<<RESUME_BUTTON) ); |
| enableControls( (1<<CLOSE_BUTTON) + (1<<CANCEL_BUTTON) ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msDownloadError) ) ); |
| focusControl( CLOSE_BUTTON ); |
| break; |
| case UPDATESTATE_DOWNLOAD_AVAIL: |
| showControls( 0 ); |
| enableControls( (1<<CLOSE_BUTTON) + (1<<INSTALL_BUTTON) ); |
| setControlProperty( TEXT_STATUS, UNISTRING("Text"), uno::Any( substVariables(msReady2Install) ) ); |
| setControlProperty( TEXT_DESCRIPTION, UNISTRING("Text"), uno::Any( substVariables(msDownloadDescr) ) ); |
| focusControl( INSTALL_BUTTON ); |
| break; |
| case UPDATESTATE_AUTO_START: |
| case UPDATESTATES_COUNT: |
| //do nothing, only count! |
| break; |
| } |
| |
| meLastState = eState; |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::searchAndReplaceAll( rtl::OUString &rText, |
| const rtl::OUString &rWhat, |
| const rtl::OUString &rWith ) const |
| { |
| sal_Int32 nIndex = rText.indexOf( rWhat ); |
| |
| while ( nIndex != -1 ) |
| { |
| rText = rText.replaceAt( nIndex, rWhat.getLength(), rWith ); |
| nIndex = rText.indexOf( rWhat, nIndex ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| rtl::OUString UpdateHandler::loadString( const uno::Reference< resource::XResourceBundle > xBundle, |
| sal_Int32 nResourceId ) const |
| { |
| rtl::OUString sString; |
| rtl::OUString sKey = UNISTRING( "string:" ) + rtl::OUString::valueOf( nResourceId ); |
| |
| try |
| { |
| OSL_VERIFY( xBundle->getByName( sKey ) >>= sString ); |
| } |
| catch( const uno::Exception& ) |
| { |
| OSL_ENSURE( false, "UpdateHandler::loadString: caught an exception!" ); |
| sString = UNISTRING("Missing ") + sKey; |
| } |
| |
| return sString; |
| } |
| |
| rtl::OUString UpdateHandler::substVariables( const rtl::OUString &rSource ) const |
| { |
| rtl::OUString sString( rSource ); |
| |
| searchAndReplaceAll( sString, UNISTRING( "%NEXTVERSION" ), msNextVersion ); |
| searchAndReplaceAll( sString, UNISTRING( "%DOWNLOAD_PATH" ), msDownloadPath ); |
| searchAndReplaceAll( sString, UNISTRING( "%FILE_NAME" ), msDownloadFile ); |
| searchAndReplaceAll( sString, UNISTRING( "%PERCENT" ), rtl::OUString::valueOf( mnPercent ) ); |
| |
| return sString; |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::loadStrings() |
| { |
| if ( mbStringsLoaded ) |
| return; |
| else |
| mbStringsLoaded = true; |
| |
| uno::Reference< resource::XResourceBundleLoader > xLoader; |
| try |
| { |
| uno::Any aValue( mxContext->getValueByName( |
| UNISTRING( "/singletons/com.sun.star.resource.OfficeResourceLoader" ) ) ); |
| OSL_VERIFY( aValue >>= xLoader ); |
| } |
| catch( const uno::Exception& ) |
| { |
| OSL_ENSURE( false, "UpdateHandler::loadStrings: could not create the resource loader!" ); |
| } |
| |
| if ( !xLoader.is() ) return; |
| |
| uno::Reference< resource::XResourceBundle > xBundle; |
| |
| try |
| { |
| xBundle = xLoader->loadBundle_Default( UNISTRING( "upd" ) ); |
| } |
| catch( const resource::MissingResourceException& ) |
| { |
| OSL_ENSURE( false, "UpdateHandler::loadStrings: missing the resource bundle!" ); |
| } |
| |
| if ( !xBundle.is() ) return; |
| |
| msChecking = loadString( xBundle, RID_UPDATE_STR_CHECKING ); |
| msCheckingError = loadString( xBundle, RID_UPDATE_STR_CHECKING_ERR ); |
| msNoUpdFound = loadString( xBundle, RID_UPDATE_STR_NO_UPD_FOUND ); |
| |
| msUpdFound = loadString( xBundle, RID_UPDATE_STR_UPD_FOUND ); |
| setFullVersion( msUpdFound ); |
| |
| msDlgTitle = loadString( xBundle, RID_UPDATE_STR_DLG_TITLE ); |
| msDownloadPause = loadString( xBundle, RID_UPDATE_STR_DOWNLOAD_PAUSE ); |
| msDownloadError = loadString( xBundle, RID_UPDATE_STR_DOWNLOAD_ERR ); |
| msDownloadWarning = loadString( xBundle, RID_UPDATE_STR_DOWNLOAD_WARN ); |
| msDownloadDescr = loadString( xBundle, RID_UPDATE_STR_DOWNLOAD_DESCR ); |
| msDownloadNotAvail = loadString( xBundle, RID_UPDATE_STR_DOWNLOAD_UNAVAIL ); |
| msDownloading = loadString( xBundle, RID_UPDATE_STR_DOWNLOADING ); |
| msReady2Install = loadString( xBundle, RID_UPDATE_STR_READY_INSTALL ); |
| msCancelTitle = loadString( xBundle, RID_UPDATE_STR_CANCEL_TITLE ); |
| msCancelMessage = loadString( xBundle, RID_UPDATE_STR_CANCEL_DOWNLOAD ); |
| msInstallMessage = loadString( xBundle, RID_UPDATE_STR_BEGIN_INSTALL ); |
| msInstallNow = loadString( xBundle, RID_UPDATE_STR_INSTALL_NOW ); |
| msInstallLater = loadString( xBundle, RID_UPDATE_STR_INSTALL_LATER ); |
| msInstallError = loadString( xBundle, RID_UPDATE_STR_INSTALL_ERROR ); |
| msOverwriteWarning = loadString( xBundle, RID_UPDATE_STR_OVERWRITE_WARNING ); |
| msPercent = loadString( xBundle, RID_UPDATE_STR_PERCENT ); |
| msReloadWarning = loadString( xBundle, RID_UPDATE_STR_RELOAD_WARNING ); |
| msReloadReload = loadString( xBundle, RID_UPDATE_STR_RELOAD_RELOAD ); |
| msReloadContinue = loadString( xBundle, RID_UPDATE_STR_RELOAD_CONTINUE ); |
| |
| msStatusFL = loadString( xBundle, RID_UPDATE_FT_STATUS ); |
| msDescription = loadString( xBundle, RID_UPDATE_FT_DESCRIPTION ); |
| |
| msClose = loadString( xBundle, RID_UPDATE_BTN_CLOSE ); |
| msDownload = loadString( xBundle, RID_UPDATE_BTN_DOWNLOAD ); |
| msInstall = loadString( xBundle, RID_UPDATE_BTN_INSTALL ); |
| msPauseBtn = loadString( xBundle, RID_UPDATE_BTN_PAUSE ); |
| msResumeBtn = loadString( xBundle, RID_UPDATE_BTN_RESUME ); |
| msCancelBtn = loadString( xBundle, RID_UPDATE_BTN_CANCEL ); |
| |
| // all update states before UPDATESTATE_UPDATE_AVAIL don't have a bubble |
| // so we can ignore them |
| for ( int i=0; i < (int)(UPDATESTATES_COUNT - UPDATESTATE_UPDATE_AVAIL); i++ ) |
| { |
| msBubbleTexts[ i ] = loadString( xBundle, RID_UPDATE_BUBBLE_TEXT_START + i ); |
| msBubbleTitles[ i ] = loadString( xBundle, RID_UPDATE_BUBBLE_T_TEXT_START + i ); |
| } |
| |
| for ( int i=0; i < BUTTON_COUNT; i++ ) |
| { |
| msButtonIDs[ i ] = UNISTRING("BUTTON_") + rtl::OUString::valueOf( (sal_Int32) i ); |
| } |
| } |
| |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::startThrobber( bool bStart ) |
| { |
| uno::Reference< awt::XControlContainer > xContainer( mxUpdDlg, uno::UNO_QUERY ); |
| uno::Reference< awt::XAnimation > xThrobber( xContainer->getControl( CTRL_THROBBER ), uno::UNO_QUERY ); |
| |
| if ( xThrobber.is() ) |
| { |
| if ( bStart ) |
| xThrobber->startAnimation(); |
| else |
| xThrobber->stopAnimation(); |
| } |
| |
| uno::Reference< awt::XWindow > xWindow( xContainer->getControl( CTRL_THROBBER ), uno::UNO_QUERY ); |
| if (xWindow.is() ) |
| xWindow->setVisible( bStart ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::setControlProperty( const rtl::OUString &rCtrlName, |
| const rtl::OUString &rPropName, |
| const uno::Any &rPropValue ) |
| { |
| if ( !mxUpdDlg.is() ) return; |
| |
| uno::Reference< awt::XControlContainer > xContainer( mxUpdDlg, uno::UNO_QUERY ); |
| uno::Reference< awt::XControl > xControl( xContainer->getControl( rCtrlName ), uno::UNO_QUERY_THROW ); |
| uno::Reference< awt::XControlModel > xControlModel( xControl->getModel(), uno::UNO_QUERY_THROW ); |
| uno::Reference< beans::XPropertySet > xPropSet( xControlModel, uno::UNO_QUERY_THROW ); |
| |
| try { |
| xPropSet->setPropertyValue( rPropName, rPropValue ); |
| } |
| catch( const beans::UnknownPropertyException& ) |
| { |
| OSL_ENSURE( false, "UpdateHandler::setControlProperty: caught an exception!" ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::showControl( const rtl::OUString &rCtrlName, bool bShow ) |
| { |
| uno::Reference< awt::XControlContainer > xContainer( mxUpdDlg, uno::UNO_QUERY ); |
| |
| if ( !xContainer.is() ) |
| { |
| OSL_ENSURE( false, "UpdateHandler::showControl: could not get control container!" ); |
| return; |
| } |
| |
| uno::Reference< awt::XWindow > xWindow( xContainer->getControl( rCtrlName ), uno::UNO_QUERY ); |
| if ( xWindow.is() ) |
| xWindow->setVisible( bShow ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::focusControl( DialogControls eID ) |
| { |
| uno::Reference< awt::XControlContainer > xContainer( mxUpdDlg, uno::UNO_QUERY ); |
| |
| if ( !xContainer.is() ) |
| { |
| OSL_ENSURE( false, "UpdateHandler::focusControl: could not get control container!" ); |
| return; |
| } |
| |
| OSL_ENSURE( (eID < BUTTON_COUNT), "UpdateHandler::focusControl: id to big!" ); |
| |
| uno::Reference< awt::XWindow > xWindow( xContainer->getControl( msButtonIDs[(short)eID] ), uno::UNO_QUERY ); |
| if ( xWindow.is() ) |
| xWindow->setFocus(); |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::insertControlModel( uno::Reference< awt::XControlModel > & rxDialogModel, |
| rtl::OUString const & rServiceName, |
| rtl::OUString const & rControlName, |
| awt::Rectangle const & rPosSize, |
| uno::Sequence< beans::NamedValue > const & rProps ) |
| { |
| uno::Reference< lang::XMultiServiceFactory > xFactory (rxDialogModel, uno::UNO_QUERY_THROW); |
| uno::Reference< awt::XControlModel > xModel (xFactory->createInstance (rServiceName), uno::UNO_QUERY_THROW); |
| uno::Reference< beans::XPropertySet > xPropSet (xModel, uno::UNO_QUERY_THROW); |
| |
| for (sal_Int32 i = 0, n = rProps.getLength(); i < n; i++) |
| { |
| xPropSet->setPropertyValue (rProps[i].Name, rProps[i].Value); |
| } |
| |
| // @see awt/UnoControlDialogElement.idl |
| xPropSet->setPropertyValue( UNISTRING("Name"), uno::Any (rControlName) ); |
| xPropSet->setPropertyValue( UNISTRING("PositionX"), uno::Any (rPosSize.X) ); |
| xPropSet->setPropertyValue( UNISTRING("PositionY"), uno::Any (rPosSize.Y) ); |
| xPropSet->setPropertyValue( UNISTRING("Height"), uno::Any (rPosSize.Height) ); |
| xPropSet->setPropertyValue( UNISTRING("Width"), uno::Any (rPosSize.Width) ); |
| |
| // insert by Name into DialogModel container |
| uno::Reference< container::XNameContainer > xContainer (rxDialogModel, uno::UNO_QUERY_THROW); |
| xContainer->insertByName( rControlName, uno::Any (uno::Reference< uno::XInterface >(xModel, uno::UNO_QUERY))); |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::setFullVersion( rtl::OUString& rString ) |
| { |
| if( !mxContext.is() ) |
| throw uno::RuntimeException( UNISTRING( "getProductName: empty component context" ), *this ); |
| |
| uno::Reference< lang::XMultiComponentFactory > xServiceManager( mxContext->getServiceManager() ); |
| |
| if( !xServiceManager.is() ) |
| throw uno::RuntimeException( UNISTRING( "getProductName: unable to obtain service manager from component context" ), *this ); |
| |
| uno::Reference< lang::XMultiServiceFactory > xConfigurationProvider( |
| xServiceManager->createInstanceWithContext( UNISTRING( "com.sun.star.configuration.ConfigurationProvider" ), mxContext ), |
| uno::UNO_QUERY_THROW); |
| |
| beans::PropertyValue aProperty; |
| aProperty.Name = UNISTRING( "nodepath" ); |
| aProperty.Value = uno::makeAny( UNISTRING("org.openoffice.Setup/Product") ); |
| |
| uno::Sequence< uno::Any > aArgumentList( 1 ); |
| aArgumentList[0] = uno::makeAny( aProperty ); |
| |
| uno::Reference< uno::XInterface > xConfigAccess; |
| xConfigAccess = xConfigurationProvider->createInstanceWithArguments( UNISTRING("com.sun.star.configuration.ConfigurationAccess"), |
| aArgumentList ); |
| |
| uno::Reference< container::XNameAccess > xNameAccess( xConfigAccess, uno::UNO_QUERY_THROW ); |
| |
| rtl::OUString aProductVersion; |
| rtl::OUString aProductFullVersion; |
| |
| xNameAccess->getByName(UNISTRING("ooSetupVersion")) >>= aProductVersion; |
| aProductFullVersion = aProductVersion; |
| |
| sal_Int32 nVerIndex = rString.indexOf( aProductVersion ); |
| if ( nVerIndex != -1 ) |
| { |
| rtl::OUString aPackageVersion = UNISTRING( "${$OOO_BASE_DIR/program/" SAL_CONFIGFILE("version") ":OOOPackageVersion}" ); |
| rtl::Bootstrap::expandMacros( aPackageVersion ); |
| |
| if ( aPackageVersion.getLength() ) |
| { |
| sal_Int32 nTokIndex = 0; |
| rtl::OUString aVersionMinor = aPackageVersion.getToken( 1, '.', nTokIndex ); |
| rtl::OUString aVersionMicro; |
| |
| if ( nTokIndex > 0 ) |
| aVersionMicro = aPackageVersion.getToken( 0, '.', nTokIndex ); |
| |
| if ( aVersionMinor.getLength() == 0 ) |
| aVersionMinor = UNISTRING( "0" ); |
| if ( aVersionMicro.getLength() == 0 ) |
| aVersionMicro = UNISTRING( "0" ); |
| |
| sal_Int32 nIndex = aProductFullVersion.indexOf( '.' ); |
| if ( nIndex == -1 ) |
| { |
| aProductFullVersion += UNISTRING( "." ); |
| aProductFullVersion += aVersionMinor; |
| } |
| else |
| { |
| nIndex = aProductFullVersion.indexOf( '.', nIndex+1 ); |
| } |
| if ( nIndex == -1 ) |
| { |
| aProductFullVersion += UNISTRING( "." ); |
| aProductFullVersion += aVersionMicro; |
| } |
| else |
| { |
| aProductFullVersion = aProductFullVersion.replaceAt( nIndex+1, aProductFullVersion.getLength()-nIndex-1, aVersionMicro ); |
| } |
| } |
| rString = rString.replaceAt( nVerIndex, aProductVersion.getLength(), aProductFullVersion ); |
| } |
| } |
| |
| //-------------------------------------------------------------------- |
| bool UpdateHandler::showWarning( const rtl::OUString &rWarningText ) const |
| { |
| bool bRet = false; |
| |
| uno::Reference< awt::XControl > xControl( mxUpdDlg, uno::UNO_QUERY ); |
| if ( !xControl.is() ) return bRet; |
| |
| uno::Reference< awt::XWindowPeer > xPeer = xControl->getPeer(); |
| if ( !xPeer.is() ) return bRet; |
| |
| uno::Reference< awt::XToolkit > xToolkit = xPeer->getToolkit(); |
| if ( !xToolkit.is() ) return bRet; |
| |
| awt::WindowDescriptor aDescriptor; |
| |
| sal_Int32 nWindowAttributes = awt::WindowAttribute::BORDER | awt::WindowAttribute::MOVEABLE | awt::WindowAttribute::CLOSEABLE; |
| nWindowAttributes |= awt::VclWindowPeerAttribute::YES_NO; |
| nWindowAttributes |= awt::VclWindowPeerAttribute::DEF_NO; |
| |
| aDescriptor.Type = awt::WindowClass_MODALTOP; |
| aDescriptor.WindowServiceName = UNISTRING( "warningbox" ); |
| aDescriptor.ParentIndex = -1; |
| aDescriptor.Parent = xPeer; |
| aDescriptor.Bounds = awt::Rectangle( 10, 10, 250, 150 ); |
| aDescriptor.WindowAttributes = nWindowAttributes; |
| |
| uno::Reference< awt::XMessageBox > xMsgBox( xToolkit->createWindow( aDescriptor ), uno::UNO_QUERY ); |
| if ( xMsgBox.is() ) |
| { |
| mbShowsMessageBox = true; |
| sal_Int16 nRet; |
| // xMsgBox->setCaptionText( msCancelTitle ); |
| xMsgBox->setMessageText( rWarningText ); |
| nRet = xMsgBox->execute(); |
| if ( nRet == 2 ) // RET_YES == 2 |
| bRet = true; |
| mbShowsMessageBox = false; |
| } |
| |
| uno::Reference< lang::XComponent > xComponent( xMsgBox, uno::UNO_QUERY ); |
| if ( xComponent.is() ) |
| xComponent->dispose(); |
| |
| return bRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool UpdateHandler::showWarning( const rtl::OUString &rWarningText, |
| const rtl::OUString &rBtnText_1, |
| const rtl::OUString &rBtnText_2 ) const |
| { |
| bool bRet = false; |
| |
| uno::Reference< awt::XControl > xControl( mxUpdDlg, uno::UNO_QUERY ); |
| if ( !xControl.is() ) return bRet; |
| |
| uno::Reference< awt::XWindowPeer > xPeer = xControl->getPeer(); |
| if ( !xPeer.is() ) return bRet; |
| |
| uno::Reference< awt::XToolkit > xToolkit = xPeer->getToolkit(); |
| if ( !xToolkit.is() ) return bRet; |
| |
| awt::WindowDescriptor aDescriptor; |
| |
| sal_Int32 nWindowAttributes = awt::WindowAttribute::BORDER | awt::WindowAttribute::MOVEABLE | awt::WindowAttribute::CLOSEABLE; |
| nWindowAttributes |= awt::VclWindowPeerAttribute::YES_NO; |
| nWindowAttributes |= awt::VclWindowPeerAttribute::DEF_NO; |
| |
| aDescriptor.Type = awt::WindowClass_MODALTOP; |
| aDescriptor.WindowServiceName = UNISTRING( "warningbox" ); |
| aDescriptor.ParentIndex = -1; |
| aDescriptor.Parent = xPeer; |
| aDescriptor.Bounds = awt::Rectangle( 10, 10, 250, 150 ); |
| aDescriptor.WindowAttributes = nWindowAttributes; |
| |
| uno::Reference< awt::XMessageBox > xMsgBox( xToolkit->createWindow( aDescriptor ), uno::UNO_QUERY ); |
| if ( xMsgBox.is() ) |
| { |
| uno::Reference< awt::XVclContainer > xMsgBoxCtrls( xMsgBox, uno::UNO_QUERY ); |
| if ( xMsgBoxCtrls.is() ) |
| { |
| uno::Sequence< uno::Reference< awt::XWindow > > xChildren = xMsgBoxCtrls->getWindows(); |
| |
| for ( long i=0; i < xChildren.getLength(); i++ ) |
| { |
| uno::Reference< awt::XVclWindowPeer > xMsgBoxCtrl( xChildren[i], uno::UNO_QUERY ); |
| if ( xMsgBoxCtrl.is() ) |
| { |
| bool bIsDefault = true; |
| uno::Any aValue = xMsgBoxCtrl->getProperty( UNISTRING("DefaultButton") ); |
| aValue >>= bIsDefault; |
| if ( bIsDefault ) |
| xMsgBoxCtrl->setProperty( UNISTRING("Text"), uno::Any( rBtnText_1 ) ); |
| else |
| xMsgBoxCtrl->setProperty( UNISTRING("Text"), uno::Any( rBtnText_2 ) ); |
| } |
| } |
| } |
| |
| sal_Int16 nRet; |
| // xMsgBox->setCaptionText( msCancelTitle ); |
| mbShowsMessageBox = true; |
| xMsgBox->setMessageText( rWarningText ); |
| nRet = xMsgBox->execute(); |
| if ( nRet == 2 ) // RET_YES == 2 |
| bRet = true; |
| |
| mbShowsMessageBox = false; |
| } |
| |
| uno::Reference< lang::XComponent > xComponent( xMsgBox, uno::UNO_QUERY ); |
| if ( xComponent.is() ) |
| xComponent->dispose(); |
| |
| return bRet; |
| } |
| |
| //-------------------------------------------------------------------- |
| bool UpdateHandler::showOverwriteWarning( const rtl::OUString& rFileName ) const |
| { |
| rtl::OUString aMsg( msReloadWarning ); |
| searchAndReplaceAll( aMsg, UNISTRING( "%FILENAME" ), rFileName ); |
| searchAndReplaceAll( aMsg, UNISTRING( "%DOWNLOAD_PATH" ), msDownloadPath ); |
| return showWarning( aMsg, msReloadContinue, msReloadReload ); |
| } |
| |
| //-------------------------------------------------------------------- |
| bool UpdateHandler::showOverwriteWarning() const |
| { |
| return showWarning( msOverwriteWarning ); |
| } |
| |
| //-------------------------------------------------------------------- |
| #define BUTTON_HEIGHT 14 |
| #define BUTTON_WIDTH 50 |
| #define BUTTON_X_OFFSET 7 |
| #define BUTTON_Y_OFFSET 3 |
| #define LABEL_HEIGHT 10 |
| |
| #define DIALOG_WIDTH 300 |
| #define DIALOG_BORDER 5 |
| #define INNER_BORDER 3 |
| #define TEXT_OFFSET 1 |
| #define BOX_HEIGHT1 ( LABEL_HEIGHT + 3*BUTTON_HEIGHT + 2*BUTTON_Y_OFFSET + 2*INNER_BORDER ) |
| #define BOX_HEIGHT2 50 |
| #define EDIT_WIDTH ( DIALOG_WIDTH - 2 * DIALOG_BORDER ) |
| #define BOX1_BTN_X ( DIALOG_BORDER + EDIT_WIDTH - BUTTON_WIDTH - INNER_BORDER ) |
| #define BOX1_BTN_Y ( DIALOG_BORDER + LABEL_HEIGHT + INNER_BORDER) |
| #define THROBBER_WIDTH 16 |
| #define THROBBER_HEIGHT 16 |
| #define THROBBER_X_POS ( DIALOG_BORDER + 8 ) |
| #define THROBBER_Y_POS ( DIALOG_BORDER + 23 ) |
| #define BUTTON_BAR_HEIGHT 24 |
| #define LABEL_OFFSET ( LABEL_HEIGHT + 4 ) |
| #define DIALOG_HEIGHT ( BOX_HEIGHT1 + BOX_HEIGHT2 + LABEL_OFFSET + BUTTON_BAR_HEIGHT + 3 * DIALOG_BORDER ) |
| #define LABEL_Y_POS ( 2 * DIALOG_BORDER + BOX_HEIGHT1 ) |
| #define EDIT2_Y_POS ( LABEL_Y_POS + LABEL_HEIGHT ) |
| #define BUTTON_BAR_Y_POS ( EDIT2_Y_POS + DIALOG_BORDER + BOX_HEIGHT2 ) |
| #define BUTTON_Y_POS ( BUTTON_BAR_Y_POS + 8 ) |
| #define CLOSE_BTN_X ( DIALOG_WIDTH - DIALOG_BORDER - BUTTON_WIDTH ) |
| #define INSTALL_BTN_X ( CLOSE_BTN_X - 2 * BUTTON_X_OFFSET - BUTTON_WIDTH ) |
| #define DOWNLOAD_BTN_X ( INSTALL_BTN_X - BUTTON_X_OFFSET - BUTTON_WIDTH ) |
| #define PROGRESS_WIDTH 80 |
| #define PROGRESS_HEIGHT 10 |
| #define PROGRESS_X_POS ( DIALOG_BORDER + 8 ) |
| #define PROGRESS_Y_POS ( DIALOG_BORDER + 2*LABEL_OFFSET ) |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::showControls( short nControls ) |
| { |
| // The buttons from CANCEL_BUTTON to RESUME_BUTTON will be shown or |
| // hidden on demand |
| short nShiftMe; |
| for ( int i = 0; i <= (int)RESUME_BUTTON; i++ ) |
| { |
| nShiftMe = (short)(nControls >> i); |
| showControl( msButtonIDs[i], (bool)(nShiftMe & 0x01) ); |
| } |
| |
| nShiftMe = (short)(nControls >> THROBBER_CTRL); |
| startThrobber( (bool)(nShiftMe & 0x01) ); |
| |
| nShiftMe = (short)(nControls >> PROGRESS_CTRL); |
| showControl( CTRL_PROGRESS, (bool)(nShiftMe & 0x01) ); |
| showControl( TEXT_PERCENT, (bool)(nShiftMe & 0x01) ); |
| |
| // Status text needs to be smaller, when there are buttons at the right side of the dialog |
| if ( ( nControls & ( (1<<CANCEL_BUTTON) + (1<<PAUSE_BUTTON) + (1<<RESUME_BUTTON) ) ) != 0 ) |
| setControlProperty( TEXT_STATUS, UNISTRING("Width"), uno::Any( sal_Int32(EDIT_WIDTH - BUTTON_WIDTH - 2*INNER_BORDER - TEXT_OFFSET ) ) ); |
| else |
| setControlProperty( TEXT_STATUS, UNISTRING("Width"), uno::Any( sal_Int32(EDIT_WIDTH - 2*TEXT_OFFSET ) ) ); |
| |
| // Status text needs to be taller, when we show the progress bar |
| if ( ( nControls & ( 1<<PROGRESS_CTRL ) ) != 0 ) |
| setControlProperty( TEXT_STATUS, UNISTRING("Height"), uno::Any( sal_Int32(LABEL_HEIGHT) ) ); |
| else |
| setControlProperty( TEXT_STATUS, UNISTRING("Height"), uno::Any( sal_Int32(BOX_HEIGHT1 - 4*TEXT_OFFSET - LABEL_HEIGHT ) ) ); |
| } |
| |
| //-------------------------------------------------------------------- |
| void UpdateHandler::createDialog() |
| { |
| if ( !mxContext.is() ) |
| { |
| OSL_ASSERT( false ); |
| return; |
| } |
| |
| uno::Reference< lang::XMultiComponentFactory > xServiceManager( mxContext->getServiceManager() ); |
| |
| if( xServiceManager.is() ) |
| { |
| uno::Reference< frame::XDesktop > xDesktop( |
| xServiceManager->createInstanceWithContext( UNISTRING( "com.sun.star.frame.Desktop"), mxContext ), |
| uno::UNO_QUERY ); |
| if ( xDesktop.is() ) |
| xDesktop->addTerminateListener( this ); |
| } |
| |
| loadStrings(); |
| |
| uno::Reference< lang::XMultiComponentFactory > xFactory( mxContext->getServiceManager(), uno::UNO_QUERY_THROW ); |
| uno::Reference< awt::XControlModel > xControlModel( xFactory->createInstanceWithContext( |
| UNISTRING("com.sun.star.awt.UnoControlDialogModel"), |
| mxContext), uno::UNO_QUERY_THROW ); |
| { |
| // @see awt/UnoControlDialogModel.idl |
| uno::Reference< beans::XPropertySet > xPropSet( xControlModel, uno::UNO_QUERY_THROW ); |
| |
| xPropSet->setPropertyValue( UNISTRING("Title"), uno::Any( msDlgTitle ) ); |
| xPropSet->setPropertyValue( UNISTRING("Closeable"), uno::Any( true ) ); |
| xPropSet->setPropertyValue( UNISTRING("Enabled"), uno::Any( true ) ); |
| xPropSet->setPropertyValue( UNISTRING("Moveable"), uno::Any( true ) ); |
| xPropSet->setPropertyValue( UNISTRING("Sizeable"), uno::Any( true ) ); |
| xPropSet->setPropertyValue( UNISTRING("DesktopAsParent"), uno::Any( true ) ); |
| xPropSet->setPropertyValue( UNISTRING("PositionX"), uno::Any(sal_Int32( 100 )) ); |
| xPropSet->setPropertyValue( UNISTRING("PositionY"), uno::Any(sal_Int32( 100 )) ); |
| xPropSet->setPropertyValue( UNISTRING("Width"), uno::Any(sal_Int32( DIALOG_WIDTH )) ); |
| xPropSet->setPropertyValue( UNISTRING("Height"), uno::Any(sal_Int32( DIALOG_HEIGHT )) ); |
| xPropSet->setPropertyValue( UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_DLG ) ) ); |
| } |
| { // Label (fixed text) <status> |
| uno::Sequence< beans::NamedValue > aProps(1); |
| |
| setProperty( aProps, 0, UNISTRING("Label"), uno::Any( msStatusFL ) ); |
| |
| insertControlModel( xControlModel, FIXED_TEXT_MODEL, UNISTRING( "fixedLineStatus" ), |
| awt::Rectangle( DIALOG_BORDER+1, DIALOG_BORDER, EDIT_WIDTH-2, LABEL_HEIGHT ), |
| aProps ); |
| } |
| { // box around <status> text |
| uno::Sequence< beans::NamedValue > aProps; |
| |
| insertControlModel( xControlModel, GROUP_BOX_MODEL, UNISTRING( "StatusBox" ), |
| awt::Rectangle( DIALOG_BORDER, DIALOG_BORDER + LABEL_HEIGHT, EDIT_WIDTH, BOX_HEIGHT1 - LABEL_HEIGHT ), |
| aProps ); |
| } |
| { // Text (multiline edit) <status> |
| uno::Sequence< beans::NamedValue > aProps(7); |
| |
| setProperty( aProps, 0, UNISTRING("Text"), uno::Any( substVariables(msChecking) ) ); |
| setProperty( aProps, 1, UNISTRING("Border"), uno::Any( sal_Int16( 0 ) ) ); |
| setProperty( aProps, 2, UNISTRING("PaintTransparent"), uno::Any( true ) ); |
| setProperty( aProps, 3, UNISTRING("MultiLine"), uno::Any( true ) ); |
| setProperty( aProps, 4, UNISTRING("ReadOnly"), uno::Any( true ) ); |
| setProperty( aProps, 5, UNISTRING("AutoVScroll"), uno::Any( true ) ); |
| setProperty( aProps, 6, UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_STATUS ) ) ); |
| |
| insertControlModel( xControlModel, EDIT_FIELD_MODEL, TEXT_STATUS, |
| awt::Rectangle( DIALOG_BORDER + TEXT_OFFSET, |
| DIALOG_BORDER + LABEL_HEIGHT + TEXT_OFFSET, |
| EDIT_WIDTH - 2*TEXT_OFFSET, |
| BOX_HEIGHT1 - 4*TEXT_OFFSET - LABEL_HEIGHT ), |
| aProps ); |
| } |
| { // Text (edit) <percent> |
| uno::Sequence< beans::NamedValue > aProps(4); |
| |
| setProperty( aProps, 0, UNISTRING("Text"), uno::Any( msPercent ) ); |
| setProperty( aProps, 1, UNISTRING("Border"), uno::Any( sal_Int16( 0 ) ) ); |
| setProperty( aProps, 2, UNISTRING("PaintTransparent"), uno::Any( true ) ); |
| setProperty( aProps, 3, UNISTRING("ReadOnly"), uno::Any( true ) ); |
| |
| insertControlModel( xControlModel, EDIT_FIELD_MODEL, TEXT_PERCENT, |
| awt::Rectangle( PROGRESS_X_POS + PROGRESS_WIDTH + DIALOG_BORDER, |
| PROGRESS_Y_POS, |
| EDIT_WIDTH - PROGRESS_WIDTH - BUTTON_WIDTH - 2*DIALOG_BORDER, |
| LABEL_HEIGHT ), |
| aProps ); |
| } |
| { // pause button |
| uno::Sequence< beans::NamedValue > aProps(5); |
| |
| setProperty( aProps, 0, UNISTRING("DefaultButton"), uno::Any( false ) ); |
| setProperty( aProps, 1, UNISTRING("Enabled"), uno::Any( true ) ); |
| setProperty( aProps, 2, UNISTRING("PushButtonType"), uno::Any( sal_Int16(awt::PushButtonType_STANDARD) ) ); |
| setProperty( aProps, 3, UNISTRING("Label"), uno::Any( msPauseBtn ) ); |
| setProperty( aProps, 4, UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_PAUSE ) ) ); |
| |
| insertControlModel ( xControlModel, BUTTON_MODEL, msButtonIDs[PAUSE_BUTTON], |
| awt::Rectangle( BOX1_BTN_X, BOX1_BTN_Y, BUTTON_WIDTH, BUTTON_HEIGHT ), |
| aProps ); |
| } |
| { // resume button |
| uno::Sequence< beans::NamedValue > aProps(5); |
| |
| setProperty( aProps, 0, UNISTRING("DefaultButton"), uno::Any( false ) ); |
| setProperty( aProps, 1, UNISTRING("Enabled"), uno::Any( true ) ); |
| setProperty( aProps, 2, UNISTRING("PushButtonType"), uno::Any( sal_Int16(awt::PushButtonType_STANDARD) ) ); |
| setProperty( aProps, 3, UNISTRING("Label"), uno::Any( msResumeBtn ) ); |
| setProperty( aProps, 4, UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_RESUME ) ) ); |
| |
| insertControlModel ( xControlModel, BUTTON_MODEL, msButtonIDs[RESUME_BUTTON], |
| awt::Rectangle( BOX1_BTN_X, |
| BOX1_BTN_Y + BUTTON_Y_OFFSET + BUTTON_HEIGHT, |
| BUTTON_WIDTH, |
| BUTTON_HEIGHT ), |
| aProps ); |
| } |
| { // abort button |
| uno::Sequence< beans::NamedValue > aProps(5); |
| |
| setProperty( aProps, 0, UNISTRING("DefaultButton"), uno::Any( false ) ); |
| setProperty( aProps, 1, UNISTRING("Enabled"), uno::Any( true ) ); |
| setProperty( aProps, 2, UNISTRING("PushButtonType"), uno::Any( sal_Int16(awt::PushButtonType_STANDARD) ) ); |
| setProperty( aProps, 3, UNISTRING("Label"), uno::Any( msCancelBtn ) ); |
| setProperty( aProps, 4, UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_CANCEL ) ) ); |
| |
| insertControlModel ( xControlModel, BUTTON_MODEL, msButtonIDs[CANCEL_BUTTON], |
| awt::Rectangle( BOX1_BTN_X, |
| BOX1_BTN_Y + (2*(BUTTON_HEIGHT+BUTTON_Y_OFFSET)), |
| BUTTON_WIDTH, |
| BUTTON_HEIGHT ), |
| aProps ); |
| } |
| { // Label (FixedText) <description> |
| uno::Sequence< beans::NamedValue > aProps(1); |
| |
| setProperty( aProps, 0, UNISTRING("Label"), uno::Any( msDescription ) ); |
| |
| insertControlModel( xControlModel, FIXED_TEXT_MODEL, UNISTRING( "fixedTextDescription" ), |
| awt::Rectangle( DIALOG_BORDER+1, LABEL_Y_POS, EDIT_WIDTH-2, LABEL_HEIGHT ), |
| aProps ); |
| } |
| { // box around <description> text |
| uno::Sequence< beans::NamedValue > aProps; |
| |
| insertControlModel( xControlModel, GROUP_BOX_MODEL, UNISTRING( "DescriptionBox" ), |
| awt::Rectangle( DIALOG_BORDER, EDIT2_Y_POS, EDIT_WIDTH, BOX_HEIGHT2 ), |
| aProps ); |
| } |
| { // Text (MultiLineEdit) <description> |
| uno::Sequence< beans::NamedValue > aProps(7); |
| |
| setProperty( aProps, 0, UNISTRING("Text"), uno::Any( rtl::OUString() ) ); |
| setProperty( aProps, 1, UNISTRING("Border"), uno::Any( sal_Int16( 0 ) ) ); |
| setProperty( aProps, 2, UNISTRING("PaintTransparent"), uno::Any( true ) ); |
| setProperty( aProps, 3, UNISTRING("MultiLine"), uno::Any( true ) ); |
| setProperty( aProps, 4, UNISTRING("ReadOnly"), uno::Any( true ) ); |
| setProperty( aProps, 5, UNISTRING("AutoVScroll"), uno::Any( true ) ); |
| setProperty( aProps, 6, UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_DESCRIPTION ) ) ); |
| |
| insertControlModel( xControlModel, EDIT_FIELD_MODEL, TEXT_DESCRIPTION, |
| awt::Rectangle( DIALOG_BORDER + TEXT_OFFSET, |
| EDIT2_Y_POS + 2*TEXT_OFFSET, |
| EDIT_WIDTH - 3*TEXT_OFFSET, |
| BOX_HEIGHT2 - 3*TEXT_OFFSET ), |
| aProps ); |
| } |
| { // @see awt/UnoControlFixedLineModel.idl |
| uno::Sequence< beans::NamedValue > aProps(1); |
| |
| setProperty( aProps, 0, UNISTRING("Orientation"), uno::Any( sal_Int32( 0 ) ) ); |
| |
| insertControlModel( xControlModel, FIXED_LINE_MODEL, UNISTRING("fixedLine"), |
| awt::Rectangle( 0, BUTTON_BAR_Y_POS, DIALOG_WIDTH, 5 ), |
| aProps ); |
| } |
| { // close button // @see awt/UnoControlButtonModel.idl |
| uno::Sequence< beans::NamedValue > aProps(5); |
| |
| setProperty( aProps, 0, UNISTRING("DefaultButton"), uno::Any( false ) ); |
| setProperty( aProps, 1, UNISTRING("Enabled"), uno::Any( true ) ); |
| // [property] short PushButtonType |
| // with own "ButtonActionListener" |
| setProperty( aProps, 2, UNISTRING("PushButtonType"), uno::Any( sal_Int16(awt::PushButtonType_STANDARD) ) ); |
| // with default ActionListener => endDialog(). |
| // setProperty( aProps, 2, UNISTRING("PushButtonType"), uno::Any( sal_Int16(awt::PushButtonType_CANCEL) ) ); |
| // [property] string Label // only if PushButtonType_STANDARD |
| setProperty( aProps, 3, UNISTRING("Label"), uno::Any( msClose ) ); |
| setProperty( aProps, 4, UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_CLOSE ) ) ); |
| |
| insertControlModel ( xControlModel, BUTTON_MODEL, msButtonIDs[ CLOSE_BUTTON ], |
| awt::Rectangle( CLOSE_BTN_X, BUTTON_Y_POS, BUTTON_WIDTH, BUTTON_HEIGHT ), |
| aProps ); |
| } |
| { // install button |
| uno::Sequence< beans::NamedValue > aProps(5); |
| |
| setProperty( aProps, 0, UNISTRING("DefaultButton"), uno::Any( false ) ); |
| setProperty( aProps, 1, UNISTRING("Enabled"), uno::Any( true ) ); |
| setProperty( aProps, 2, UNISTRING("PushButtonType"), uno::Any( sal_Int16(awt::PushButtonType_STANDARD) ) ); |
| setProperty( aProps, 3, UNISTRING("Label"), uno::Any( msInstall ) ); |
| setProperty( aProps, 4, UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_INSTALL ) ) ); |
| |
| insertControlModel ( xControlModel, BUTTON_MODEL, msButtonIDs[INSTALL_BUTTON], |
| awt::Rectangle( INSTALL_BTN_X, BUTTON_Y_POS, BUTTON_WIDTH, BUTTON_HEIGHT ), |
| aProps ); |
| } |
| { // download button |
| uno::Sequence< beans::NamedValue > aProps(5); |
| |
| setProperty( aProps, 0, UNISTRING("DefaultButton"), uno::Any( false ) ); |
| setProperty( aProps, 1, UNISTRING("Enabled"), uno::Any( true ) ); |
| setProperty( aProps, 2, UNISTRING("PushButtonType"), uno::Any( sal_Int16(awt::PushButtonType_STANDARD) ) ); |
| setProperty( aProps, 3, UNISTRING("Label"), uno::Any( msDownload ) ); |
| setProperty( aProps, 4, UNISTRING("HelpURL"), uno::Any( UNISTRING( INET_HID_SCHEME ) + rtl::OUString::createFromAscii( HID_CHECK_FOR_UPD_DOWNLOAD ) ) ); |
| |
| insertControlModel ( xControlModel, BUTTON_MODEL, msButtonIDs[DOWNLOAD_BUTTON], |
| awt::Rectangle( DOWNLOAD_BTN_X, BUTTON_Y_POS, BUTTON_WIDTH, BUTTON_HEIGHT ), |
| aProps ); |
| } |
| { // help button |
| uno::Sequence< beans::NamedValue > aProps(3); |
| |
| setProperty( aProps, 0, UNISTRING("DefaultButton"), uno::Any( false ) ); |
| setProperty( aProps, 1, UNISTRING("Enabled"), uno::Any( true ) ); |
| setProperty( aProps, 2, UNISTRING("PushButtonType"), uno::Any( sal_Int16(awt::PushButtonType_HELP) ) ); |
| |
| insertControlModel( xControlModel, BUTTON_MODEL, msButtonIDs[HELP_BUTTON], |
| awt::Rectangle( DIALOG_BORDER, BUTTON_Y_POS, BUTTON_WIDTH, BUTTON_HEIGHT ), |
| aProps ); |
| } |
| { // @see awt/UnoControlThrobberModel.idl |
| uno::Sequence< beans::NamedValue > aProps; |
| |
| insertControlModel( xControlModel, UNISTRING("com.sun.star.awt.SpinningProgressControlModel"), CTRL_THROBBER, |
| awt::Rectangle( THROBBER_X_POS, THROBBER_Y_POS, THROBBER_WIDTH, THROBBER_HEIGHT), |
| aProps ); |
| } |
| { // @see awt/UnoControlProgressBarModel.idl |
| uno::Sequence< beans::NamedValue > aProps(4); |
| setProperty( aProps, 0, UNISTRING("Enabled"), uno::Any( true ) ); |
| setProperty( aProps, 1, UNISTRING("ProgressValue"), uno::Any( sal_Int32( 0 ) ) ); |
| setProperty( aProps, 2, UNISTRING("ProgressValueMax"), uno::Any( sal_Int32( 100 ) ) ); |
| setProperty( aProps, 3, UNISTRING("ProgressValueMin"), uno::Any( sal_Int32( 0 ) ) ); |
| |
| insertControlModel( xControlModel, UNISTRING("com.sun.star.awt.UnoControlProgressBarModel"), CTRL_PROGRESS, |
| awt::Rectangle( PROGRESS_X_POS, PROGRESS_Y_POS, PROGRESS_WIDTH, PROGRESS_HEIGHT ), |
| aProps); |
| } |
| |
| uno::Reference< awt::XControl > xControl( |
| xFactory->createInstanceWithContext( UNISTRING("com.sun.star.awt.UnoControlDialog"), mxContext), |
| uno::UNO_QUERY_THROW ); |
| xControl->setModel( xControlModel ); |
| |
| if ( mbVisible == false ) |
| { |
| uno::Reference< awt::XWindow > xWindow( xControl, uno::UNO_QUERY ); |
| |
| if ( xWindow.is() ) |
| xWindow->setVisible( false ); |
| } |
| |
| xControl->createPeer( NULL, NULL ); |
| { |
| uno::Reference< awt::XControlContainer > xContainer (xControl, uno::UNO_QUERY); |
| for ( int i = 0; i < HELP_BUTTON; i++ ) |
| { |
| uno::Reference< awt::XButton > xButton ( xContainer->getControl( msButtonIDs[i] ), uno::UNO_QUERY); |
| if (xButton.is()) |
| { |
| xButton->setActionCommand( msButtonIDs[i] ); |
| xButton->addActionListener( this ); |
| } |
| } |
| } |
| |
| mxUpdDlg.set( xControl, uno::UNO_QUERY_THROW ); |
| mnLastCtrlState = -1; |
| } |
