/************************************************************** * * 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_desktop.hxx" #include "sal/config.h" #include #include #include #include #include #include #include "boost/optional.hpp" #include "com/sun/star/awt/Rectangle.hpp" #include "com/sun/star/awt/WindowAttribute.hpp" #include "com/sun/star/awt/WindowClass.hpp" #include "com/sun/star/awt/WindowDescriptor.hpp" #include "com/sun/star/awt/XToolkit.hpp" #include "com/sun/star/awt/XWindow.hpp" #include "com/sun/star/awt/XWindowPeer.hpp" #include "com/sun/star/beans/NamedValue.hpp" #include "com/sun/star/beans/Optional.hpp" #include "com/sun/star/beans/PropertyValue.hpp" #include "com/sun/star/beans/XPropertySet.hpp" #include "com/sun/star/container/XNameAccess.hpp" #include "com/sun/star/container/XNameContainer.hpp" #include "com/sun/star/deployment/DeploymentException.hpp" #include "com/sun/star/deployment/UpdateInformationProvider.hpp" #include "com/sun/star/deployment/XPackage.hpp" #include "com/sun/star/deployment/XExtensionManager.hpp" #include "com/sun/star/deployment/ExtensionManager.hpp" #include "com/sun/star/deployment/XUpdateInformationProvider.hpp" #include "com/sun/star/frame/XDesktop.hpp" #include "com/sun/star/frame/XDispatch.hpp" #include "com/sun/star/frame/XDispatchProvider.hpp" #include "com/sun/star/lang/IllegalArgumentException.hpp" #include "com/sun/star/lang/XMultiComponentFactory.hpp" #include "com/sun/star/lang/XSingleServiceFactory.hpp" #include "com/sun/star/system/SystemShellExecuteFlags.hpp" #include "com/sun/star/system/SystemShellExecute.hpp" #include "com/sun/star/task/XAbortChannel.hpp" #include "com/sun/star/task/XJob.hpp" #include "com/sun/star/ucb/CommandAbortedException.hpp" #include "com/sun/star/ucb/CommandFailedException.hpp" #include "com/sun/star/ucb/XCommandEnvironment.hpp" #include "com/sun/star/uno/Any.hxx" #include "com/sun/star/uno/Exception.hpp" #include "com/sun/star/uno/Reference.hxx" #include "com/sun/star/uno/RuntimeException.hpp" #include "com/sun/star/uno/Sequence.hxx" #include "com/sun/star/uno/XInterface.hpp" #include "com/sun/star/util/URL.hpp" #include "com/sun/star/util/XChangesBatch.hpp" #include "com/sun/star/util/XURLTransformer.hpp" #include "com/sun/star/xml/dom/XElement.hpp" #include "com/sun/star/xml/dom/XNode.hpp" #include "osl/diagnose.h" #include "rtl/bootstrap.hxx" #include "rtl/ref.hxx" #include "rtl/string.h" #include "rtl/ustrbuf.hxx" #include "rtl/ustring.h" #include "rtl/ustring.hxx" #include "sal/types.h" #include "svtools/svlbitm.hxx" #include "svtools/svlbox.hxx" #include #include "svx/checklbx.hxx" #include "tools/gen.hxx" #include "tools/link.hxx" #include "tools/resid.hxx" #include "tools/resmgr.hxx" #include "tools/solar.h" #include "tools/string.hxx" #include "vcl/button.hxx" #include "vcl/dialog.hxx" #include "vcl/fixed.hxx" #include "vcl/image.hxx" #include "vcl/msgbox.hxx" #include "vcl/svapp.hxx" #include "vos/mutex.hxx" #include "comphelper/processfactory.hxx" #include "dp_dependencies.hxx" #include "dp_descriptioninfoset.hxx" #include "dp_identifier.hxx" #include "dp_version.hxx" #include "dp_misc.h" #include "dp_update.hxx" #include "dp_gui.h" #include "dp_gui.hrc" #include "dp_gui_thread.hxx" #include "dp_gui_updatedata.hxx" #include "dp_gui_updatedialog.hxx" #include "dp_gui_shared.hxx" #include "dp_gui_system.hxx" class KeyEvent; class MouseEvent; class Window; namespace com { namespace sun { namespace star { namespace uno { class XComponentContext; } } } } using namespace ::com::sun::star; using dp_gui::UpdateDialog; namespace { static sal_Unicode const LF = 0x000A; static sal_Unicode const CR = 0x000D; static const sal_uInt16 CMD_ENABLE_UPDATE = 1; static const sal_uInt16 CMD_IGNORE_UPDATE = 2; static const sal_uInt16 CMD_IGNORE_ALL_UPDATES = 3; #define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) ) #define IGNORED_UPDATES OUSTR("/org.openoffice.Office.ExtensionManager/ExtensionUpdateData/IgnoredUpdates") #define PROPERTY_VERSION OUSTR("Version") enum Kind { ENABLED_UPDATE, DISABLED_UPDATE, SPECIFIC_ERROR }; rtl::OUString confineToParagraph(rtl::OUString const & text) { // Confine arbitrary text to a single paragraph in a dp_gui::AutoScrollEdit. // This assumes that U+000A and U+000D are the only paragraph separators in // a dp_gui::AutoScrollEdit, and that replacing them with a single space // each is acceptable: return text.replace(LF, ' ').replace(CR, ' '); } } struct UpdateDialog::DisabledUpdate { rtl::OUString name; uno::Sequence< rtl::OUString > unsatisfiedDependencies; // We also want to show release notes and publisher for disabled updates ::com::sun::star::uno::Reference< ::com::sun::star::xml::dom::XNode > aUpdateInfo; sal_uInt16 m_nID; }; struct UpdateDialog::SpecificError { rtl::OUString name; rtl::OUString message; sal_uInt16 m_nID; }; //------------------------------------------------------------------------------ struct UpdateDialog::IgnoredUpdate { rtl::OUString sExtensionID; rtl::OUString sVersion; bool bRemoved; IgnoredUpdate( const rtl::OUString &rExtensionID, const rtl::OUString &rVersion ); }; //------------------------------------------------------------------------------ UpdateDialog::IgnoredUpdate::IgnoredUpdate( const rtl::OUString &rExtensionID, const rtl::OUString &rVersion ): sExtensionID( rExtensionID ), sVersion( rVersion ), bRemoved( false ) {} //------------------------------------------------------------------------------ struct UpdateDialog::Index { Kind m_eKind; bool m_bIgnored; sal_uInt16 m_nID; sal_uInt16 m_nIndex; rtl::OUString m_aName; Index( Kind theKind, sal_uInt16 nID, sal_uInt16 nIndex, const rtl::OUString &rName ); }; //------------------------------------------------------------------------------ UpdateDialog::Index::Index( Kind theKind, sal_uInt16 nID, sal_uInt16 nIndex, const rtl::OUString &rName ): m_eKind( theKind ), m_bIgnored( false ), m_nID( nID ), m_nIndex( nIndex ), m_aName( rName ) {} //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ class UpdateDialog::Thread: public dp_gui::Thread { public: Thread( uno::Reference< uno::XComponentContext > const & context, UpdateDialog & dialog, const std::vector< uno::Reference< deployment::XPackage > > & vExtensionList); void stop(); private: Thread(UpdateDialog::Thread &); // not defined void operator =(UpdateDialog::Thread &); // not defined struct Entry { explicit Entry( uno::Reference< deployment::XPackage > const & thePackage, rtl::OUString const & theVersion); uno::Reference< deployment::XPackage > package; rtl::OUString version; //Indicates that the extension provides its own update URLs. //If this is true, then we must not use the default update //URL to find the update information. bool bProvidesOwnUpdate; uno::Reference< xml::dom::XNode > info; UpdateDialog::DisabledUpdate disableUpdate; dp_gui::UpdateData updateData; }; // A multimap in case an extension is installed in "user", "shared" or "bundled" typedef std::map< rtl::OUString, Entry > Map; virtual ~Thread(); virtual void execute(); #if 0 void handleGeneralError(uno::Any const & exception) const; #endif void handleSpecificError( uno::Reference< deployment::XPackage > const & package, uno::Any const & exception) const; uno::Sequence< uno::Reference< xml::dom::XElement > > getUpdateInformation( uno::Reference< deployment::XPackage > const & package, uno::Sequence< rtl::OUString > const & urls, rtl::OUString const & identifier) const; void getOwnUpdateInformation( uno::Reference< deployment::XPackage > const & package, Map * map); ::rtl::OUString getUpdateDisplayString( dp_gui::UpdateData const & data, ::rtl::OUString const & version = ::rtl::OUString()) const; void prepareUpdateData( ::com::sun::star::uno::Reference< ::com::sun::star::xml::dom::XNode > const & updateInfo, UpdateDialog::DisabledUpdate & out_du, dp_gui::UpdateData & out_data) const; bool update( UpdateDialog::DisabledUpdate & du, dp_gui::UpdateData & data) const; uno::Reference< uno::XComponentContext > m_context; UpdateDialog & m_dialog; std::vector< uno::Reference< deployment::XPackage > > m_vExtensionList; uno::Reference< deployment::XUpdateInformationProvider > m_updateInformation; uno::Reference< task::XInteractionHandler > m_xInteractionHdl; // guarded by Application::GetSolarMutex(): uno::Reference< task::XAbortChannel > m_abort; bool m_stop; }; UpdateDialog::Thread::Thread( uno::Reference< uno::XComponentContext > const & context, UpdateDialog & dialog, const std::vector< uno::Reference< deployment::XPackage > > &vExtensionList): m_context(context), m_dialog(dialog), m_vExtensionList(vExtensionList), m_updateInformation( deployment::UpdateInformationProvider::create(context)), m_stop(false) { if( m_context.is() ) { uno::Reference< lang::XMultiComponentFactory > xServiceManager( m_context->getServiceManager() ); if( xServiceManager.is() ) { m_xInteractionHdl = uno::Reference< task::XInteractionHandler > ( xServiceManager->createInstanceWithContext( OUSTR( "com.sun.star.task.InteractionHandler" ), m_context), uno::UNO_QUERY ); if ( m_xInteractionHdl.is() ) m_updateInformation->setInteractionHandler( m_xInteractionHdl ); } } } void UpdateDialog::Thread::stop() { uno::Reference< task::XAbortChannel > abort; { vos::OGuard g(Application::GetSolarMutex()); abort = m_abort; m_stop = true; } if (abort.is()) { abort->sendAbort(); } m_updateInformation->cancel(); } UpdateDialog::Thread::Entry::Entry( uno::Reference< deployment::XPackage > const & thePackage, rtl::OUString const & theVersion): package(thePackage), version(theVersion), bProvidesOwnUpdate(false), updateData(thePackage) { } UpdateDialog::Thread::~Thread() { if ( m_xInteractionHdl.is() ) m_updateInformation->setInteractionHandler( uno::Reference< task::XInteractionHandler > () ); } void UpdateDialog::Thread::execute() { { vos::OGuard g( Application::GetSolarMutex() ); if ( m_stop ) { return; } } uno::Reference extMgr = deployment::ExtensionManager::get(m_context); std::vector, uno::Any > > errors; dp_misc::UpdateInfoMap updateInfoMap = dp_misc::getOnlineUpdateInfos( m_context, extMgr, m_updateInformation, &m_vExtensionList, errors); typedef std::vector, uno::Any> >::const_iterator ITERROR; for (ITERROR ite = errors.begin(); ite != errors.end(); ite ++) handleSpecificError(ite->first, ite->second); for (dp_misc::UpdateInfoMap::iterator i(updateInfoMap.begin()); i != updateInfoMap.end(); i++) { dp_misc::UpdateInfo const & info = i->second; UpdateData updateData(info.extension); DisabledUpdate disableUpdate; //determine if online updates meet the requirements prepareUpdateData(info.info, disableUpdate, updateData); //determine if the update is installed in the user or shared repository rtl::OUString sOnlineVersion; if (info.info.is()) sOnlineVersion = info.version; rtl::OUString sVersionUser; rtl::OUString sVersionShared; rtl::OUString sVersionBundled; uno::Sequence< uno::Reference< deployment::XPackage> > extensions; try { extensions = extMgr->getExtensionsWithSameIdentifier( dp_misc::getIdentifier(info.extension), info.extension->getName(), uno::Reference()); } catch (lang::IllegalArgumentException& ) { OSL_ASSERT(0); continue; } catch (css::ucb::CommandFailedException& ) { OSL_ASSERT(0); continue; } OSL_ASSERT(extensions.getLength() == 3); if (extensions[0].is() ) sVersionUser = extensions[0]->getVersion(); if (extensions[1].is() ) sVersionShared = extensions[1]->getVersion(); if (extensions[2].is() ) sVersionBundled = extensions[2]->getVersion(); bool bSharedReadOnly = extMgr->isReadOnlyRepository(OUSTR("shared")); dp_misc::UPDATE_SOURCE sourceUser = dp_misc::isUpdateUserExtension( bSharedReadOnly, sVersionUser, sVersionShared, sVersionBundled, sOnlineVersion); dp_misc::UPDATE_SOURCE sourceShared = dp_misc::isUpdateSharedExtension( bSharedReadOnly, sVersionShared, sVersionBundled, sOnlineVersion); uno::Reference updateSource; if (sourceUser != dp_misc::UPDATE_SOURCE_NONE) { if (sourceUser == dp_misc::UPDATE_SOURCE_SHARED) { updateData.aUpdateSource = extensions[1]; updateData.updateVersion = extensions[1]->getVersion(); } else if (sourceUser == dp_misc::UPDATE_SOURCE_BUNDLED) { updateData.aUpdateSource = extensions[2]; updateData.updateVersion = extensions[2]->getVersion(); } if (!update(disableUpdate, updateData)) return; } if (sourceShared != dp_misc::UPDATE_SOURCE_NONE) { if (sourceShared == dp_misc::UPDATE_SOURCE_BUNDLED) { updateData.aUpdateSource = extensions[2]; updateData.updateVersion = extensions[2]->getVersion(); } updateData.bIsShared = true; if (!update(disableUpdate, updateData)) return; } } vos::OGuard g(Application::GetSolarMutex()); if (!m_stop) { m_dialog.checkingDone(); } } #if 0 void UpdateDialog::Thread::handleGeneralError(uno::Any const & exception) const { rtl::OUString message; uno::Exception e; if (exception >>= e) { message = e.Message; } vos::OGuard g(Application::GetSolarMutex()); if (!m_stop) { m_dialog.addGeneralError(message); } } #endif //Parameter package can be null void UpdateDialog::Thread::handleSpecificError( uno::Reference< deployment::XPackage > const & package, uno::Any const & exception) const { UpdateDialog::SpecificError data; if (package.is()) data.name = package->getDisplayName(); uno::Exception e; if (exception >>= e) { data.message = e.Message; } vos::OGuard g(Application::GetSolarMutex()); if (!m_stop) { m_dialog.addSpecificError(data); } } ::rtl::OUString UpdateDialog::Thread::getUpdateDisplayString( dp_gui::UpdateData const & data, ::rtl::OUString const & version) const { OSL_ASSERT(data.aInstalledPackage.is()); rtl::OUStringBuffer b(data.aInstalledPackage->getDisplayName()); b.append(static_cast< sal_Unicode >(' ')); { vos::OGuard g( Application::GetSolarMutex() ); if(!m_stop) b.append(m_dialog.m_version); } b.append(static_cast< sal_Unicode >(' ')); if (version.getLength()) b.append(version); else b.append(data.updateVersion); if (data.sWebsiteURL.getLength()) { b.append(static_cast< sal_Unicode >(' ')); { vos::OGuard g( Application::GetSolarMutex() ); if(!m_stop) b.append(m_dialog.m_browserbased); } } return b.makeStringAndClear(); } /** out_data will only be filled if all dependencies are ok. */ void UpdateDialog::Thread::prepareUpdateData( uno::Reference< xml::dom::XNode > const & updateInfo, UpdateDialog::DisabledUpdate & out_du, dp_gui::UpdateData & out_data) const { if (!updateInfo.is()) return; dp_misc::DescriptionInfoset infoset(m_context, updateInfo); OSL_ASSERT(infoset.getVersion().getLength() != 0); uno::Sequence< uno::Reference< xml::dom::XElement > > ds( dp_misc::Dependencies::check(infoset)); out_du.aUpdateInfo = updateInfo; out_du.unsatisfiedDependencies.realloc(ds.getLength()); for (sal_Int32 i = 0; i < ds.getLength(); ++i) { out_du.unsatisfiedDependencies[i] = dp_misc::Dependencies::getErrorText(ds[i]); } const ::boost::optional< ::rtl::OUString> updateWebsiteURL(infoset.getLocalizedUpdateWebsiteURL()); out_du.name = getUpdateDisplayString(out_data, infoset.getVersion()); if (out_du.unsatisfiedDependencies.getLength() == 0) { out_data.aUpdateInfo = updateInfo; out_data.updateVersion = infoset.getVersion(); if (updateWebsiteURL) out_data.sWebsiteURL = *updateWebsiteURL; } } bool UpdateDialog::Thread::update( UpdateDialog::DisabledUpdate & du, dp_gui::UpdateData & data) const { bool ret = false; if (du.unsatisfiedDependencies.getLength() == 0) { vos::OGuard g(Application::GetSolarMutex()); if (!m_stop) { m_dialog.addEnabledUpdate(getUpdateDisplayString(data), data); } ret = !m_stop; } else { vos::OGuard g(Application::GetSolarMutex()); if (!m_stop) { m_dialog.addDisabledUpdate(du); } ret = !m_stop; } return ret; } // UpdateDialog ---------------------------------------------------------- UpdateDialog::UpdateDialog( uno::Reference< uno::XComponentContext > const & context, Window * parent, const std::vector > &vExtensionList, std::vector< dp_gui::UpdateData > * updateData): ModalDialog(parent,DpGuiResId(RID_DLG_UPDATE)), m_context(context), m_checking(this, DpGuiResId(RID_DLG_UPDATE_CHECKING)), m_throbber(this, DpGuiResId(RID_DLG_UPDATE_THROBBER)), m_update(this, DpGuiResId(RID_DLG_UPDATE_UPDATE)), m_updates( *this, DpGuiResId(RID_DLG_UPDATE_UPDATES), Image(DpGuiResId(RID_DLG_UPDATE_NORMALALERT)), Image(DpGuiResId(RID_DLG_UPDATE_HIGHCONTRASTALERT))), m_all(this, DpGuiResId(RID_DLG_UPDATE_ALL)), m_description(this, DpGuiResId(RID_DLG_UPDATE_DESCRIPTION)), m_PublisherLabel(this, DpGuiResId(RID_DLG_UPDATE_PUBLISHER_LABEL)), m_PublisherLink(this, DpGuiResId(RID_DLG_UPDATE_PUBLISHER_LINK)), m_ReleaseNotesLabel(this, DpGuiResId(RID_DLG_UPDATE_RELEASENOTES_LABEL)), m_ReleaseNotesLink(this, DpGuiResId(RID_DLG_UPDATE_RELEASENOTES_LINK)), m_descriptions(this, DpGuiResId(RID_DLG_UPDATE_DESCRIPTIONS)), m_line(this, DpGuiResId(RID_DLG_UPDATE_LINE)), m_help(this, DpGuiResId(RID_DLG_UPDATE_HELP)), m_ok(this, DpGuiResId(RID_DLG_UPDATE_OK)), m_close(this, DpGuiResId(RID_DLG_UPDATE_CLOSE)), m_error(String(DpGuiResId(RID_DLG_UPDATE_ERROR))), m_none(String(DpGuiResId(RID_DLG_UPDATE_NONE))), m_noInstallable(String(DpGuiResId(RID_DLG_UPDATE_NOINSTALLABLE))), m_failure(String(DpGuiResId(RID_DLG_UPDATE_FAILURE))), m_unknownError(String(DpGuiResId(RID_DLG_UPDATE_UNKNOWNERROR))), m_noDescription(String(DpGuiResId(RID_DLG_UPDATE_NODESCRIPTION))), m_noInstall(String(DpGuiResId(RID_DLG_UPDATE_NOINSTALL))), m_noDependency(String(DpGuiResId(RID_DLG_UPDATE_NODEPENDENCY))), m_noDependencyCurVer(String(DpGuiResId(RID_DLG_UPDATE_NODEPENDENCY_CUR_VER))), m_browserbased(String(DpGuiResId(RID_DLG_UPDATE_BROWSERBASED))), m_version(String(DpGuiResId(RID_DLG_UPDATE_VERSION))), m_ignoredUpdate(String(DpGuiResId(RID_DLG_UPDATE_IGNORED_UPDATE))), m_updateData(*updateData), m_thread( new UpdateDialog::Thread( context, *this, vExtensionList)), m_nFirstLineDelta(0), m_nOneLineMissing(0), m_nLastID(1), m_bModified( false ) // TODO: check! // , // m_extensionManagerDialog(extensionManagerDialog) { OSL_ASSERT(updateData != NULL); m_xExtensionManager = deployment::ExtensionManager::get( context ); uno::Reference< awt::XToolkit > toolkit; try { toolkit = uno::Reference< awt::XToolkit >( (uno::Reference< lang::XMultiComponentFactory >( m_context->getServiceManager(), uno::UNO_QUERY_THROW)-> createInstanceWithContext( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.awt.Toolkit")), m_context)), uno::UNO_QUERY_THROW); } catch (uno::RuntimeException &) { throw; } catch (uno::Exception & e) { throw uno::RuntimeException(e.Message, e.Context); } m_updates.SetSelectHdl(LINK(this, UpdateDialog, selectionHandler)); m_all.SetToggleHdl(LINK(this, UpdateDialog, allHandler)); m_ok.SetClickHdl(LINK(this, UpdateDialog, okHandler)); m_close.SetClickHdl(LINK(this, UpdateDialog, closeHandler)); if ( ! dp_misc::office_is_running()) m_help.Disable(); FreeResource(); initDescription(); getIgnoredUpdates(); } //------------------------------------------------------------------------------ UpdateDialog::~UpdateDialog() { storeIgnoredUpdates(); for ( std::vector< UpdateDialog::Index* >::iterator i( m_ListboxEntries.begin() ); i != m_ListboxEntries.end(); ++i ) { delete (*i); } for ( std::vector< UpdateDialog::IgnoredUpdate* >::iterator i( m_ignoredUpdates.begin() ); i != m_ignoredUpdates.end(); ++i ) { delete (*i); } } //------------------------------------------------------------------------------ sal_Bool UpdateDialog::Close() { m_thread->stop(); return ModalDialog::Close(); } short UpdateDialog::Execute() { m_throbber.start(); m_thread->launch(); return ModalDialog::Execute(); } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ UpdateDialog::CheckListBox::CheckListBox( UpdateDialog & dialog, ResId const & resource, Image const & normalStaticImage, Image const & highContrastStaticImage ): SvxCheckListBox( &dialog, resource, normalStaticImage, highContrastStaticImage ), m_ignoreUpdate( String( DpGuiResId( RID_DLG_UPDATE_IGNORE ) ) ), m_ignoreAllUpdates( String( DpGuiResId( RID_DLG_UPDATE_IGNORE_ALL ) ) ), m_enableUpdate( String( DpGuiResId( RID_DLG_UPDATE_ENABLE ) ) ), m_dialog(dialog) {} //------------------------------------------------------------------------------ UpdateDialog::CheckListBox::~CheckListBox() {} //------------------------------------------------------------------------------ sal_uInt16 UpdateDialog::CheckListBox::getItemCount() const { sal_uLong i = GetEntryCount(); OSL_ASSERT(i <= std::numeric_limits< sal_uInt16 >::max()); return sal::static_int_cast< sal_uInt16 >(i); } //------------------------------------------------------------------------------ void UpdateDialog::CheckListBox::MouseButtonDown( MouseEvent const & event ) { // When clicking on a selected entry in an SvxCheckListBox, the entry's // checkbox is toggled on mouse button down: SvxCheckListBox::MouseButtonDown( event ); if ( event.IsRight() ) { handlePopupMenu( event.GetPosPixel() ); } m_dialog.enableOk(); } //------------------------------------------------------------------------------ void UpdateDialog::CheckListBox::MouseButtonUp(MouseEvent const & event) { // When clicking on an entry's checkbox in an SvxCheckListBox, the entry's // checkbox is toggled on mouse button up: SvxCheckListBox::MouseButtonUp(event); m_dialog.enableOk(); } void UpdateDialog::CheckListBox::KeyInput(KeyEvent const & event) { SvxCheckListBox::KeyInput(event); m_dialog.enableOk(); } //------------------------------------------------------------------------------ void UpdateDialog::CheckListBox::handlePopupMenu( const Point &rPos ) { SvListEntry *pData = GetEntry( rPos ); if ( pData ) { sal_uInt16 nEntryPos = GetSelectEntryPos(); UpdateDialog::Index * p = static_cast< UpdateDialog::Index * >( GetEntryData( nEntryPos ) ); if ( ( p->m_eKind == ENABLED_UPDATE ) || ( p->m_eKind == DISABLED_UPDATE ) ) { PopupMenu aPopup; if ( p->m_bIgnored ) aPopup.InsertItem( CMD_ENABLE_UPDATE, m_enableUpdate ); else { aPopup.InsertItem( CMD_IGNORE_UPDATE, m_ignoreUpdate ); aPopup.InsertItem( CMD_IGNORE_ALL_UPDATES, m_ignoreAllUpdates ); } sal_uInt16 aCmd = aPopup.Execute( this, rPos ); if ( ( aCmd == CMD_IGNORE_UPDATE ) || ( aCmd == CMD_IGNORE_ALL_UPDATES ) ) { p->m_bIgnored = true; if ( p->m_eKind == ENABLED_UPDATE ) { RemoveEntry( nEntryPos ); m_dialog.addAdditional( p, SvLBoxButtonKind_disabledCheckbox ); } if ( aCmd == CMD_IGNORE_UPDATE ) m_dialog.setIgnoredUpdate( p, true, false ); else m_dialog.setIgnoredUpdate( p, true, true ); // TODO: reselect entry to display new description! } else if ( aCmd == CMD_ENABLE_UPDATE ) { p->m_bIgnored = false; if ( p->m_eKind == ENABLED_UPDATE ) { RemoveEntry( nEntryPos ); m_dialog.insertItem( p, SvLBoxButtonKind_enabledCheckbox ); } m_dialog.setIgnoredUpdate( p, false, false ); } } } } //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ sal_uInt16 UpdateDialog::insertItem( UpdateDialog::Index *pEntry, SvLBoxButtonKind kind ) { m_updates.InsertEntry( pEntry->m_aName, LISTBOX_APPEND, static_cast< void * >( pEntry ), kind ); for ( sal_uInt16 i = m_updates.getItemCount(); i != 0 ; ) { i -= 1; UpdateDialog::Index const * p = static_cast< UpdateDialog::Index const * >( m_updates.GetEntryData( i ) ); if ( p == pEntry ) return i; } OSL_ASSERT(0); return 0; } //------------------------------------------------------------------------------ void UpdateDialog::addAdditional( UpdateDialog::Index * index, SvLBoxButtonKind kind ) { m_all.Enable(); if (m_all.IsChecked()) { insertItem( index, kind ); m_update.Enable(); m_updates.Enable(); m_description.Enable(); m_descriptions.Enable(); } } //------------------------------------------------------------------------------ void UpdateDialog::addEnabledUpdate( rtl::OUString const & name, dp_gui::UpdateData & data ) { sal_uInt16 nIndex = sal::static_int_cast< sal_uInt16 >( m_enabledUpdates.size() ); UpdateDialog::Index *pEntry = new UpdateDialog::Index( ENABLED_UPDATE, m_nLastID, nIndex, name ); data.m_nID = m_nLastID; m_nLastID += 1; m_enabledUpdates.push_back( data ); m_ListboxEntries.push_back( pEntry ); if ( ! isIgnoredUpdate( pEntry ) ) { sal_uInt16 nPos = insertItem( pEntry, SvLBoxButtonKind_enabledCheckbox ); m_updates.CheckEntryPos( nPos ); } else addAdditional( pEntry, SvLBoxButtonKind_disabledCheckbox ); m_update.Enable(); m_updates.Enable(); m_description.Enable(); m_descriptions.Enable(); } //------------------------------------------------------------------------------ void UpdateDialog::addDisabledUpdate( UpdateDialog::DisabledUpdate & data ) { sal_uInt16 nIndex = sal::static_int_cast< sal_uInt16 >( m_disabledUpdates.size() ); UpdateDialog::Index *pEntry = new UpdateDialog::Index( DISABLED_UPDATE, m_nLastID, nIndex, data.name ); data.m_nID = m_nLastID; m_nLastID += 1; m_disabledUpdates.push_back( data ); m_ListboxEntries.push_back( pEntry ); isIgnoredUpdate( pEntry ); addAdditional( pEntry, SvLBoxButtonKind_disabledCheckbox ); } //------------------------------------------------------------------------------ void UpdateDialog::addSpecificError( UpdateDialog::SpecificError & data ) { sal_uInt16 nIndex = sal::static_int_cast< sal_uInt16 >( m_specificErrors.size() ); UpdateDialog::Index *pEntry = new UpdateDialog::Index( SPECIFIC_ERROR, m_nLastID, nIndex, data.name ); data.m_nID = m_nLastID; m_nLastID += 1; m_specificErrors.push_back( data ); m_ListboxEntries.push_back( pEntry ); addAdditional( pEntry, SvLBoxButtonKind_staticImage); } void UpdateDialog::checkingDone() { m_checking.Hide(); m_throbber.stop(); m_throbber.Hide(); if (m_updates.getItemCount() == 0) { clearDescription(); m_description.Enable(); m_descriptions.Enable(); if ( m_disabledUpdates.empty() && m_specificErrors.empty() && m_ignoredUpdates.empty() ) showDescription( m_none, false ); else showDescription( m_noInstallable, false ); } enableOk(); } void UpdateDialog::enableOk() { if (!m_checking.IsVisible()) { m_ok.Enable(m_updates.GetCheckedEntryCount() != 0); } } // ********************************************************************************* void UpdateDialog::createNotifyJob( bool bPrepareOnly, uno::Sequence< uno::Sequence< rtl::OUString > > &rItemList ) { if ( !dp_misc::office_is_running() ) return; // notify update check job try { uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() ); uno::Reference< lang::XMultiServiceFactory > xConfigProvider( xFactory->createInstance( OUSTR( "com.sun.star.configuration.ConfigurationProvider" )), uno::UNO_QUERY_THROW); beans::PropertyValue aProperty; aProperty.Name = OUSTR( "nodepath" ); aProperty.Value = uno::makeAny( OUSTR("org.openoffice.Office.Addons/AddonUI/OfficeHelp/UpdateCheckJob") ); uno::Sequence< uno::Any > aArgumentList( 1 ); aArgumentList[0] = uno::makeAny( aProperty ); uno::Reference< container::XNameAccess > xNameAccess( xConfigProvider->createInstanceWithArguments( OUSTR("com.sun.star.configuration.ConfigurationAccess"), aArgumentList ), uno::UNO_QUERY_THROW ); util::URL aURL; xNameAccess->getByName(OUSTR("URL")) >>= aURL.Complete; uno::Reference < util::XURLTransformer > xTransformer( xFactory->createInstance( OUSTR( "com.sun.star.util.URLTransformer" ) ), uno::UNO_QUERY_THROW ); xTransformer->parseStrict(aURL); uno::Reference < frame::XDesktop > xDesktop( xFactory->createInstance( OUSTR( "com.sun.star.frame.Desktop" ) ), uno::UNO_QUERY_THROW ); uno::Reference< frame::XDispatchProvider > xDispatchProvider( xDesktop->getCurrentFrame(), uno::UNO_QUERY_THROW ); uno::Reference< frame::XDispatch > xDispatch = xDispatchProvider->queryDispatch(aURL, rtl::OUString(), 0); if( xDispatch.is() ) { uno::Sequence< beans::PropertyValue > aPropList(2); aProperty.Name = OUSTR( "updateList" ); aProperty.Value = uno::makeAny( rItemList ); aPropList[0] = aProperty; aProperty.Name = OUSTR( "prepareOnly" ); aProperty.Value = uno::makeAny( bPrepareOnly ); aPropList[1] = aProperty; xDispatch->dispatch(aURL, aPropList ); } } catch( const uno::Exception& e ) { dp_misc::TRACE( OUSTR("Caught exception: ") + e.Message + OUSTR("\n thread terminated.\n\n")); } } // ********************************************************************************* void UpdateDialog::notifyMenubar( bool bPrepareOnly, bool bRecheckOnly ) { if ( !dp_misc::office_is_running() ) return; uno::Sequence< uno::Sequence< rtl::OUString > > aItemList; sal_Int32 nCount = 0; if ( ! bRecheckOnly ) { for ( sal_Int16 i = 0; i < m_updates.getItemCount(); ++i ) { uno::Sequence< rtl::OUString > aItem(2); UpdateDialog::Index const * p = static_cast< UpdateDialog::Index const * >(m_updates.GetEntryData(i)); if ( p->m_eKind == ENABLED_UPDATE ) { dp_gui::UpdateData aUpdData = m_enabledUpdates[ p->m_nIndex ]; aItem[0] = dp_misc::getIdentifier( aUpdData.aInstalledPackage ); dp_misc::DescriptionInfoset aInfoset( m_context, aUpdData.aUpdateInfo ); aItem[1] = aInfoset.getVersion(); } else if ( p->m_eKind == DISABLED_UPDATE ) continue; else continue; aItemList.realloc( nCount + 1 ); aItemList[ nCount ] = aItem; nCount += 1; } } storeIgnoredUpdates(); createNotifyJob( bPrepareOnly, aItemList ); } // ********************************************************************************* void UpdateDialog::initDescription() { m_PublisherLabel.Hide(); m_PublisherLink.Hide(); m_ReleaseNotesLabel.Hide(); m_ReleaseNotesLink.Hide(); m_descriptions.Hide(); Link aLink = LINK( this, UpdateDialog, hyperlink_clicked ); m_PublisherLink.SetClickHdl( aLink ); m_ReleaseNotesLink.SetClickHdl( aLink ); long nTextWidth = m_PublisherLabel.GetCtrlTextWidth( m_PublisherLabel.GetText() ); long nTemp = m_ReleaseNotesLabel.GetTextWidth( m_ReleaseNotesLabel.GetText() ); if ( nTemp > nTextWidth ) nTextWidth = nTemp; nTextWidth = nTextWidth * 110 / 100; Size aNewSize = m_PublisherLabel.GetSizePixel(); if ( nTextWidth > aNewSize.Width() ) { long nDelta = nTextWidth - aNewSize.Width(); aNewSize.Width() = nTextWidth; m_PublisherLabel.SetSizePixel( aNewSize ); m_ReleaseNotesLabel.SetSizePixel( aNewSize ); aNewSize = m_PublisherLink.GetSizePixel(); aNewSize.Width() = aNewSize.Width() - nDelta; Point aNewPos = m_PublisherLink.GetPosPixel(); aNewPos.X() = aNewPos.X() + nDelta; m_PublisherLink.SetPosSizePixel( aNewPos, aNewSize ); aNewPos.Y() = m_ReleaseNotesLink.GetPosPixel().Y(); m_ReleaseNotesLink.SetPosSizePixel( aNewPos, aNewSize ); } m_aFirstLinePos = m_descriptions.GetPosPixel(); m_aFirstLineSize = m_descriptions.GetSizePixel(); Size aMarginSize = LogicToPixel( Size( RSC_SP_CTRL_GROUP_X, RSC_SP_CTRL_GROUP_Y ), MAP_APPFONT ); Point aThirdLinePos = m_ReleaseNotesLabel.GetPosPixel(); aThirdLinePos.Y() = aThirdLinePos.Y() + m_ReleaseNotesLabel.GetSizePixel().Height() + aMarginSize.Height(); m_nFirstLineDelta = aThirdLinePos.Y() - m_aFirstLinePos.Y(); m_nOneLineMissing = m_ReleaseNotesLabel.GetPosPixel().Y() - m_PublisherLabel.GetPosPixel().Y(); } void UpdateDialog::clearDescription() { String sEmpty; m_PublisherLabel.Hide(); m_PublisherLink.Hide(); m_PublisherLink.SetDescription( sEmpty ); m_PublisherLink.SetURL( sEmpty ); m_ReleaseNotesLabel.Hide(); m_ReleaseNotesLink.Hide(); m_ReleaseNotesLink.SetURL( sEmpty ); if ( m_PublisherLabel.GetPosPixel().Y() == m_ReleaseNotesLabel.GetPosPixel().Y() ) { Point aNewPos = m_ReleaseNotesLabel.GetPosPixel(); aNewPos.Y() += m_nOneLineMissing; m_ReleaseNotesLabel.SetPosPixel( aNewPos ); aNewPos = m_ReleaseNotesLink.GetPosPixel(); aNewPos.Y() += m_nOneLineMissing; m_ReleaseNotesLink.SetPosPixel( aNewPos ); } m_descriptions.Hide(); m_descriptions.Clear(); m_descriptions.SetPosSizePixel( m_aFirstLinePos, m_aFirstLineSize ); } bool UpdateDialog::showDescription(uno::Reference< xml::dom::XNode > const & aUpdateInfo) { dp_misc::DescriptionInfoset infoset(m_context, aUpdateInfo); return showDescription(infoset.getLocalizedPublisherNameAndURL(), infoset.getLocalizedReleaseNotesURL()); } bool UpdateDialog::showDescription(uno::Reference< deployment::XPackage > const & aExtension) { OSL_ASSERT(aExtension.is()); beans::StringPair pubInfo = aExtension->getPublisherInfo(); return showDescription(std::make_pair(pubInfo.First, pubInfo.Second), OUSTR("")); } bool UpdateDialog::showDescription(std::pair< rtl::OUString, rtl::OUString > const & pairPublisher, rtl::OUString const & sReleaseNotes) { rtl::OUString sPub = pairPublisher.first; rtl::OUString sURL = pairPublisher.second; if ( sPub.getLength() == 0 && sURL.getLength() == 0 && sReleaseNotes.getLength() == 0 ) // nothing to show return false; bool bPublisher = false; if ( sPub.getLength() > 0 ) { m_PublisherLabel.Show(); m_PublisherLink.Show(); m_PublisherLink.SetDescription( sPub ); m_PublisherLink.SetURL( sURL ); bPublisher = true; } if ( sReleaseNotes.getLength() > 0 ) { if ( !bPublisher ) { m_ReleaseNotesLabel.SetPosPixel( m_PublisherLabel.GetPosPixel() ); m_ReleaseNotesLink.SetPosPixel( m_PublisherLink.GetPosPixel() ); } m_ReleaseNotesLabel.Show(); m_ReleaseNotesLink.Show(); m_ReleaseNotesLink.SetURL( sReleaseNotes ); } return true; } bool UpdateDialog::showDescription( const String& rDescription, bool bWithPublisher ) { if ( rDescription.Len() == 0 ) // nothing to show return false; if ( bWithPublisher ) { bool bOneLineMissing = !m_ReleaseNotesLabel.IsVisible() || !m_PublisherLabel.IsVisible(); Point aNewPos = m_aFirstLinePos; aNewPos.Y() += m_nFirstLineDelta; if ( bOneLineMissing ) aNewPos.Y() -= m_nOneLineMissing; Size aNewSize = m_aFirstLineSize; aNewSize.Height() -= m_nFirstLineDelta; if ( bOneLineMissing ) aNewSize.Height() += m_nOneLineMissing; m_descriptions.SetPosSizePixel( aNewPos, aNewSize ); } m_descriptions.Show(); m_descriptions.SetDescription( rDescription ); return true; } bool UpdateDialog::isReadOnly( const uno::Reference< deployment::XPackage > &xPackage ) const { if ( m_xExtensionManager.is() && xPackage.is() ) { return m_xExtensionManager->isReadOnlyRepository( xPackage->getRepositoryName() ); } else return true; } //------------------------------------------------------------------------------ void UpdateDialog::getIgnoredUpdates() { uno::Reference< lang::XMultiServiceFactory > xConfig( m_context->getServiceManager()->createInstanceWithContext( OUSTR("com.sun.star.configuration.ConfigurationProvider"), m_context ), uno::UNO_QUERY_THROW); beans::NamedValue aValue( OUSTR("nodepath"), uno::Any( IGNORED_UPDATES ) ); uno::Sequence< uno::Any > args(1); args[0] <<= aValue; uno::Reference< container::XNameAccess > xNameAccess( xConfig->createInstanceWithArguments( OUSTR("com.sun.star.configuration.ConfigurationAccess"), args), uno::UNO_QUERY_THROW ); uno::Sequence< rtl::OUString > aElementNames = xNameAccess->getElementNames(); for ( sal_Int32 i = 0; i < aElementNames.getLength(); i++ ) { ::rtl::OUString aIdentifier = aElementNames[i]; ::rtl::OUString aVersion; uno::Any aPropValue( uno::Reference< beans::XPropertySet >( xNameAccess->getByName( aIdentifier ), uno::UNO_QUERY_THROW )->getPropertyValue( PROPERTY_VERSION ) ); aPropValue >>= aVersion; IgnoredUpdate *pData = new IgnoredUpdate( aIdentifier, aVersion ); m_ignoredUpdates.push_back( pData ); } } //------------------------------------------------------------------------------ void UpdateDialog::storeIgnoredUpdates() { if ( m_bModified && ( m_ignoredUpdates.size() != 0 ) ) { uno::Reference< lang::XMultiServiceFactory > xConfig( m_context->getServiceManager()->createInstanceWithContext( OUSTR("com.sun.star.configuration.ConfigurationProvider"), m_context ), uno::UNO_QUERY_THROW ); beans::NamedValue aValue( OUSTR("nodepath"), uno::Any( IGNORED_UPDATES ) ); uno::Sequence< uno::Any > args(1); args[0] <<= aValue; uno::Reference< container::XNameContainer > xNameContainer( xConfig->createInstanceWithArguments( OUSTR("com.sun.star.configuration.ConfigurationUpdateAccess"), args ), uno::UNO_QUERY_THROW ); for ( std::vector< UpdateDialog::IgnoredUpdate* >::iterator i( m_ignoredUpdates.begin() ); i != m_ignoredUpdates.end(); ++i ) { if ( xNameContainer->hasByName( (*i)->sExtensionID ) ) { if ( (*i)->bRemoved ) xNameContainer->removeByName( (*i)->sExtensionID ); else uno::Reference< beans::XPropertySet >( xNameContainer->getByName( (*i)->sExtensionID ), uno::UNO_QUERY_THROW )->setPropertyValue( PROPERTY_VERSION, uno::Any( (*i)->sVersion ) ); } else if ( ! (*i)->bRemoved ) { uno::Reference< beans::XPropertySet > elem( uno::Reference< lang::XSingleServiceFactory >( xNameContainer, uno::UNO_QUERY_THROW )->createInstance(), uno::UNO_QUERY_THROW ); elem->setPropertyValue( PROPERTY_VERSION, uno::Any( (*i)->sVersion ) ); xNameContainer->insertByName( (*i)->sExtensionID, uno::Any( elem ) ); } } uno::Reference< util::XChangesBatch > xChangesBatch( xNameContainer, uno::UNO_QUERY ); if ( xChangesBatch.is() && xChangesBatch->hasPendingChanges() ) xChangesBatch->commitChanges(); } m_bModified = false; } //------------------------------------------------------------------------------ bool UpdateDialog::isIgnoredUpdate( UpdateDialog::Index * index ) { bool bIsIgnored = false; if ( m_ignoredUpdates.size() != 0 ) { rtl::OUString aExtensionID; rtl::OUString aVersion; if ( index->m_eKind == ENABLED_UPDATE ) { dp_gui::UpdateData aUpdData = m_enabledUpdates[ index->m_nIndex ]; aExtensionID = dp_misc::getIdentifier( aUpdData.aInstalledPackage ); aVersion = aUpdData.updateVersion; } else if ( index->m_eKind == DISABLED_UPDATE ) { DisabledUpdate &rData = m_disabledUpdates[ index->m_nIndex ]; dp_misc::DescriptionInfoset aInfoset( m_context, rData.aUpdateInfo ); ::boost::optional< ::rtl::OUString > aID( aInfoset.getIdentifier() ); if ( aID ) aExtensionID = *aID; aVersion = aInfoset.getVersion(); } for ( std::vector< UpdateDialog::IgnoredUpdate* >::iterator i( m_ignoredUpdates.begin() ); i != m_ignoredUpdates.end(); ++i ) { if ( (*i)->sExtensionID == aExtensionID ) { if ( ( (*i)->sVersion.getLength() == 0 ) || ( (*i)->sVersion == aVersion ) ) { bIsIgnored = true; index->m_bIgnored = true; } else // when we find another update of an ignored version, we will remove the old one to keep the ignored list small (*i)->bRemoved = true; break; } } } return bIsIgnored; } //------------------------------------------------------------------------------ void UpdateDialog::setIgnoredUpdate( UpdateDialog::Index *pIndex, bool bIgnore, bool bIgnoreAll ) { rtl::OUString aExtensionID; rtl::OUString aVersion; m_bModified = true; if ( pIndex->m_eKind == ENABLED_UPDATE ) { dp_gui::UpdateData aUpdData = m_enabledUpdates[ pIndex->m_nIndex ]; aExtensionID = dp_misc::getIdentifier( aUpdData.aInstalledPackage ); if ( !bIgnoreAll ) aVersion = aUpdData.updateVersion; } else if ( pIndex->m_eKind == DISABLED_UPDATE ) { DisabledUpdate &rData = m_disabledUpdates[ pIndex->m_nIndex ]; dp_misc::DescriptionInfoset aInfoset( m_context, rData.aUpdateInfo ); ::boost::optional< ::rtl::OUString > aID( aInfoset.getIdentifier() ); if ( aID ) aExtensionID = *aID; if ( !bIgnoreAll ) aVersion = aInfoset.getVersion(); } if ( aExtensionID.getLength() ) { bool bFound = false; for ( std::vector< UpdateDialog::IgnoredUpdate* >::iterator i( m_ignoredUpdates.begin() ); i != m_ignoredUpdates.end(); ++i ) { if ( (*i)->sExtensionID == aExtensionID ) { (*i)->sVersion = aVersion; (*i)->bRemoved = !bIgnore; bFound = true; break; } } if ( bIgnore && !bFound ) { IgnoredUpdate *pData = new IgnoredUpdate( aExtensionID, aVersion ); m_ignoredUpdates.push_back( pData ); } } } //------------------------------------------------------------------------------ IMPL_LINK(UpdateDialog, selectionHandler, void *, EMPTYARG) { rtl::OUStringBuffer b; bool bInserted = false; UpdateDialog::Index const * p = static_cast< UpdateDialog::Index const * >( m_updates.GetEntryData(m_updates.GetSelectEntryPos())); clearDescription(); if ( p != NULL ) { sal_uInt16 pos = p->m_nIndex; switch (p->m_eKind) { case ENABLED_UPDATE: { if ( m_enabledUpdates[ pos ].aUpdateSource.is() ) bInserted = showDescription( m_enabledUpdates[ pos ].aUpdateSource ); else bInserted = showDescription( m_enabledUpdates[ pos ].aUpdateInfo ); if ( p->m_bIgnored ) b.append( m_ignoredUpdate ); break; } case DISABLED_UPDATE: { bInserted = showDescription( m_disabledUpdates[pos].aUpdateInfo ); if ( p->m_bIgnored ) b.append( m_ignoredUpdate ); UpdateDialog::DisabledUpdate & data = m_disabledUpdates[ pos ]; if (data.unsatisfiedDependencies.getLength() != 0) { // create error string for version mismatch ::rtl::OUString sVersion( RTL_CONSTASCII_USTRINGPARAM("%VERSION") ); sal_Int32 nPos = m_noDependencyCurVer.indexOf( sVersion ); if ( nPos >= 0 ) { ::rtl::OUString sCurVersion( RTL_CONSTASCII_USTRINGPARAM( "${$OOO_BASE_DIR/program/" SAL_CONFIGFILE("version") ":Version:OOOPackageVersion}")); ::rtl::Bootstrap::expandMacros(sCurVersion); m_noDependencyCurVer = m_noDependencyCurVer.replaceAt( nPos, sVersion.getLength(), sCurVersion ); } b.append(m_noInstall); b.append(LF); b.append(m_noDependency); for (sal_Int32 i = 0; i < data.unsatisfiedDependencies.getLength(); ++i) { b.append(LF); b.appendAscii(RTL_CONSTASCII_STRINGPARAM(" ")); // U+2003 EM SPACE would be better than two spaces, // but some fonts do not contain it b.append( confineToParagraph( data.unsatisfiedDependencies[i])); } b.append(LF); b.appendAscii(RTL_CONSTASCII_STRINGPARAM(" ")); b.append(m_noDependencyCurVer); } break; } case SPECIFIC_ERROR: { UpdateDialog::SpecificError & data = m_specificErrors[ pos ]; b.append(m_failure); b.append(LF); b.append( data.message.getLength() == 0 ? m_unknownError : data.message ); break; } default: OSL_ASSERT(false); break; } } if ( b.getLength() == 0 ) b.append( m_noDescription ); showDescription( b.makeStringAndClear(), bInserted ); return 0; } IMPL_LINK(UpdateDialog, allHandler, void *, EMPTYARG) { if (m_all.IsChecked()) { m_update.Enable(); m_updates.Enable(); m_description.Enable(); m_descriptions.Enable(); for (std::vector< UpdateDialog::Index* >::iterator i( m_ListboxEntries.begin() ); i != m_ListboxEntries.end(); ++i ) { if ( (*i)->m_bIgnored || ( (*i)->m_eKind != ENABLED_UPDATE ) ) insertItem( (*i), SvLBoxButtonKind_disabledCheckbox ); } } else { for ( sal_uInt16 i = 0; i < m_updates.getItemCount(); ) { UpdateDialog::Index const * p = static_cast< UpdateDialog::Index const * >( m_updates.GetEntryData(i) ); if ( p->m_bIgnored || ( p->m_eKind != ENABLED_UPDATE ) ) { m_updates.RemoveEntry(i); } else { ++i; } } if (m_updates.getItemCount() == 0) { clearDescription(); m_update.Disable(); m_updates.Disable(); if (m_checking.IsVisible()) m_description.Disable(); else showDescription(m_noInstallable,false); } } return 0; } IMPL_LINK(UpdateDialog, okHandler, void *, EMPTYARG) { //If users are going to update a shared extension then we need //to warn them typedef ::std::vector::const_iterator CIT; for (CIT i = m_enabledUpdates.begin(); i < m_enabledUpdates.end(); i++) { OSL_ASSERT(i->aInstalledPackage.is()); //If the user has no write access to the shared folder then the update //for a shared extension is disable, that is it cannot be in m_enabledUpdates // OSL_ASSERT(isReadOnly(i->aInstalledPackage) == sal_False); #if 0 // TODO: check! OSL_ASSERT(m_extensionManagerDialog.get()); if (RET_CANCEL == m_extensionManagerDialog->continueUpdateForSharedExtension( this, i->aPackageManager)) { EndDialog(RET_CANCEL); } #endif } for (sal_uInt16 i = 0; i < m_updates.getItemCount(); ++i) { UpdateDialog::Index const * p = static_cast< UpdateDialog::Index const * >( m_updates.GetEntryData(i)); if (p->m_eKind == ENABLED_UPDATE && m_updates.IsChecked(i)) { m_updateData.push_back( m_enabledUpdates[ p->m_nIndex ] ); } } EndDialog(RET_OK); return 0; } IMPL_LINK(UpdateDialog, closeHandler, void *, EMPTYARG) { m_thread->stop(); EndDialog(RET_CANCEL); return 0; } IMPL_LINK( UpdateDialog, hyperlink_clicked, svt::FixedHyperlink*, pHyperlink ) { ::rtl::OUString sURL; if ( pHyperlink ) sURL = ::rtl::OUString( pHyperlink->GetURL() ); if ( sURL.getLength() == 0 ) return 0; try { uno::Reference< com::sun::star::system::XSystemShellExecute > xSystemShellExecute( com::sun::star::system::SystemShellExecute::create( m_context ) ); xSystemShellExecute->execute( sURL, ::rtl::OUString(), com::sun::star::system::SystemShellExecuteFlags::DEFAULTS); } catch (uno::Exception& ) { } return 1; }