Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1419 insertions, 0 deletions

diff --git a/sfx2/source/doc/templatedlg.cxx b/sfx2/source/doc/templatedlg.cxx
new file mode 100644
index 000000000..3979db7cf
--- /dev/null
+++ b/sfx2/source/doc/templatedlg.cxx
@@ -0,0 +1,1419 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <sfx2/templatedlg.hxx>
+
+#include <sfx2/inputdlg.hxx>
+#include <templatesearchview.hxx>
+#include <templatesearchviewitem.hxx>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/string.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/docfac.hxx>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/fcontnr.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/templatelocalview.hxx>
+#include <templatecontaineritem.hxx>
+#include <templateviewitem.hxx>
+#include <thumbnailviewitem.hxx>
+#include <sot/storage.hxx>
+#include <svtools/imagemgr.hxx>
+#include <svtools/langhelp.hxx>
+#include <tools/urlobj.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <unotools/pathoptions.hxx>
+#include <unotools/viewoptions.hxx>
+#include <vcl/event.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/configuration/theDefaultProvider.hpp>
+#include <com/sun/star/document/MacroExecMode.hpp>
+#include <com/sun/star/document/UpdateDocMode.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <com/sun/star/ui/dialogs/FolderPicker.hpp>
+#include <com/sun/star/system/SystemShellExecute.hpp>
+#include <com/sun/star/system/SystemShellExecuteFlags.hpp>
+#include <com/sun/star/task/InteractionHandler.hpp>
+
+#include <sfx2/strings.hrc>
+#include <bitmaps.hlst>
+
+const char TM_SETTING_MANAGER[] = "TemplateManager";
+const char TM_SETTING_LASTFOLDER[] = "LastFolder";
+const char TM_SETTING_LASTAPPLICATION[] = "LastApplication";
+
+#define MNI_ACTION_NEW_FOLDER "new"
+#define MNI_ACTION_RENAME_FOLDER "rename"
+#define MNI_ACTION_DELETE_FOLDER "delete"
+#define MNI_ACTION_REFRESH   "refresh"
+#define MNI_ACTION_DEFAULT   "default"
+#define MNI_WRITER           1
+#define MNI_CALC             2
+#define MNI_IMPRESS          3
+#define MNI_DRAW             4
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::embed;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::ui::dialogs;
+using namespace ::com::sun::star::document;
+
+static bool lcl_getServiceName (const OUString &rFileURL, OUString &rName );
+
+static std::vector<OUString> lcl_getAllFactoryURLs ();
+
+namespace {
+
+class SearchView_Keyword
+{
+public:
+
+    SearchView_Keyword (const OUString &rKeyword, FILTER_APPLICATION App)
+        : maKeyword(rKeyword.toAsciiLowerCase()), meApp(App)
+    {}
+
+    bool operator() (const TemplateItemProperties &rItem)
+    {
+        bool bRet = true;
+
+        INetURLObject aUrl(rItem.aPath);
+        OUString aExt = aUrl.getExtension();
+
+        if (meApp == FILTER_APPLICATION::WRITER)
+        {
+            bRet = aExt == "ott" || aExt == "stw" || aExt == "oth" || aExt == "dot" || aExt == "dotx";
+        }
+        else if (meApp == FILTER_APPLICATION::CALC)
+        {
+            bRet = aExt == "ots" || aExt == "stc" || aExt == "xlt" || aExt == "xltm" || aExt == "xltx";
+        }
+        else if (meApp == FILTER_APPLICATION::IMPRESS)
+        {
+            bRet = aExt == "otp" || aExt == "sti" || aExt == "pot" || aExt == "potm" || aExt == "potx";
+        }
+        else if (meApp == FILTER_APPLICATION::DRAW)
+        {
+            bRet = aExt == "otg" || aExt == "std";
+        }
+
+        return bRet && MatchSubstring(rItem.aName);
+    }
+
+    bool MatchSubstring( OUString const & sItemName )
+    {
+        if(maKeyword.isEmpty())
+            return false;
+        return sItemName.toAsciiLowerCase().indexOf(maKeyword) >= 0;
+    }
+
+private:
+
+    OUString maKeyword;
+    FILTER_APPLICATION meApp;
+};
+
+}
+
+/***
+ *
+ * Order items in ascending order (useful for the selection sets and move/copy operations since the associated ids
+ * change when processed by the SfxDocumentTemplates class so we want to process to ones with higher id first)
+ *
+ ***/
+
+static bool cmpSelectionItems (const ThumbnailViewItem *pItem1, const ThumbnailViewItem *pItem2)
+{
+    return pItem1->mnId > pItem2->mnId;
+}
+
+SfxTemplateManagerDlg::SfxTemplateManagerDlg(weld::Window *pParent)
+    : GenericDialogController(pParent, "sfx/ui/templatedlg.ui", "TemplateDialog")
+    , maSelTemplates(cmpSelectionItems)
+    , mxDesktop(Desktop::create(comphelper::getProcessComponentContext()))
+    , m_aUpdateDataTimer("UpdateDataTimer")
+    , mxSearchFilter(m_xBuilder->weld_entry("search_filter"))
+    , mxCBApp(m_xBuilder->weld_combo_box("filter_application"))
+    , mxCBFolder(m_xBuilder->weld_combo_box("filter_folder"))
+    , mxOKButton(m_xBuilder->weld_button("ok"))
+    , mxMoveButton(m_xBuilder->weld_button("move_btn"))
+    , mxExportButton(m_xBuilder->weld_button("export_btn"))
+    , mxImportButton(m_xBuilder->weld_button("import_btn"))
+    , mxLinkButton(m_xBuilder->weld_button("online_link"))
+    , mxCBXHideDlg(m_xBuilder->weld_check_button("hidedialogcb"))
+    , mxActionBar(m_xBuilder->weld_menu_button("action_menu"))
+    , mxSearchView(new TemplateSearchView(m_xBuilder->weld_scrolled_window("scrollsearch"),
+                                          m_xBuilder->weld_menu("contextmenu1")))
+    , mxLocalView(new SfxTemplateLocalView(m_xBuilder->weld_scrolled_window("scrolllocal"),
+                                           m_xBuilder->weld_menu("contextmenu2")))
+    , mxTemplateDefaultMenu(m_xBuilder->weld_menu("submenu"))
+    , mxSearchViewWeld(new weld::CustomWeld(*m_xBuilder, "search_view", *mxSearchView))
+    , mxLocalViewWeld(new weld::CustomWeld(*m_xBuilder, "template_view", *mxLocalView))
+{
+    // Create popup menus
+    mxActionBar->insert_item(0, MNI_ACTION_NEW_FOLDER, SfxResId(STR_CATEGORY_NEW), nullptr, nullptr, TRISTATE_INDET);
+    mxActionBar->insert_item(1, MNI_ACTION_RENAME_FOLDER, SfxResId(STR_CATEGORY_RENAME), nullptr, nullptr, TRISTATE_INDET);
+    mxActionBar->insert_item(2, MNI_ACTION_DELETE_FOLDER, SfxResId(STR_CATEGORY_DELETE), nullptr, nullptr, TRISTATE_INDET);
+    mxActionBar->insert_separator(3, "separator");
+    mxActionBar->insert_item(4, MNI_ACTION_REFRESH, SfxResId(STR_ACTION_REFRESH), nullptr, nullptr, TRISTATE_INDET);
+    mxActionBar->connect_selected(LINK(this,SfxTemplateManagerDlg,MenuSelectHdl));
+
+    mxLocalView->setItemMaxTextLength(TEMPLATE_ITEM_MAX_TEXT_LENGTH);
+    mxLocalView->setItemDimensions(TEMPLATE_ITEM_MAX_WIDTH,TEMPLATE_ITEM_THUMBNAIL_MAX_HEIGHT,
+                              TEMPLATE_ITEM_MAX_HEIGHT-TEMPLATE_ITEM_THUMBNAIL_MAX_HEIGHT,
+                              TEMPLATE_ITEM_PADDING);
+
+    mxLocalView->setItemStateHdl(LINK(this,SfxTemplateManagerDlg,TVItemStateHdl));
+    mxLocalView->setCreateContextMenuHdl(LINK(this,SfxTemplateManagerDlg, CreateContextMenuHdl));
+    mxLocalView->setOpenRegionHdl(LINK(this,SfxTemplateManagerDlg, OpenRegionHdl));
+    mxLocalView->setOpenTemplateHdl(LINK(this,SfxTemplateManagerDlg, OpenTemplateHdl));
+    mxLocalView->setEditTemplateHdl(LINK(this,SfxTemplateManagerDlg, EditTemplateHdl));
+    mxLocalView->setDeleteTemplateHdl(LINK(this,SfxTemplateManagerDlg, DeleteTemplateHdl));
+    mxLocalView->setDefaultTemplateHdl(LINK(this,SfxTemplateManagerDlg, DefaultTemplateHdl));
+
+    mxSearchView->setItemMaxTextLength(TEMPLATE_ITEM_MAX_TEXT_LENGTH);
+
+    mxSearchView->setItemDimensions(TEMPLATE_ITEM_MAX_WIDTH,TEMPLATE_ITEM_THUMBNAIL_MAX_HEIGHT,
+                                    TEMPLATE_ITEM_MAX_HEIGHT_SUB-TEMPLATE_ITEM_THUMBNAIL_MAX_HEIGHT,
+                                    TEMPLATE_ITEM_PADDING);
+
+    mxSearchView->setItemStateHdl(LINK(this,SfxTemplateManagerDlg,TVItemStateHdl));
+    mxSearchView->setCreateContextMenuHdl(LINK(this,SfxTemplateManagerDlg, CreateContextMenuHdl));
+    mxSearchView->setOpenTemplateHdl(LINK(this,SfxTemplateManagerDlg,OpenTemplateHdl));
+    mxSearchView->setEditTemplateHdl(LINK(this,SfxTemplateManagerDlg, EditTemplateHdl));
+    mxSearchView->setDeleteTemplateHdl(LINK(this,SfxTemplateManagerDlg, DeleteTemplateHdl));
+    mxSearchView->setDefaultTemplateHdl(LINK(this,SfxTemplateManagerDlg, DefaultTemplateHdl));
+
+    mxLocalView->ShowTooltips(true);
+    mxSearchView->ShowTooltips(true);
+
+    mxOKButton->connect_clicked(LINK(this, SfxTemplateManagerDlg, OkClickHdl));
+    mxMoveButton->connect_clicked(LINK(this, SfxTemplateManagerDlg, MoveClickHdl));
+    mxExportButton->connect_clicked(LINK(this, SfxTemplateManagerDlg, ExportClickHdl));
+    mxImportButton->connect_clicked(LINK(this, SfxTemplateManagerDlg, ImportClickHdl));
+    mxLinkButton->connect_clicked(LINK(this, SfxTemplateManagerDlg, LinkClickHdl));
+
+    mxSearchFilter->connect_changed(LINK(this, SfxTemplateManagerDlg, SearchUpdateHdl));
+    mxSearchFilter->connect_focus_in(LINK( this, SfxTemplateManagerDlg, GetFocusHdl ));
+    mxSearchFilter->connect_focus_out(LINK( this, SfxTemplateManagerDlg, LoseFocusHdl ));
+    mxSearchFilter->connect_key_press(LINK( this, SfxTemplateManagerDlg, KeyInputHdl));
+
+    mxActionBar->show();
+
+    createDefaultTemplateMenu();
+
+    mxLocalView->Populate();
+    mxLocalView->filterItems(ViewFilter_Application(FILTER_APPLICATION::NONE));
+
+    mxCBApp->set_active(0);
+    fillFolderComboBox();
+
+    mxExportButton->set_sensitive(false);
+    mxMoveButton->set_sensitive(false);
+    mxOKButton->set_label(SfxResId(STR_OPEN));
+
+    mxCBApp->connect_changed(LINK(this, SfxTemplateManagerDlg, SelectApplicationHdl));
+    mxCBFolder->connect_changed(LINK(this, SfxTemplateManagerDlg, SelectRegionHdl));
+
+    mxLocalView->Show();
+
+    m_aUpdateDataTimer.SetInvokeHandler(LINK(this, SfxTemplateManagerDlg, ImplUpdateDataHdl));
+    m_aUpdateDataTimer.SetDebugName( "SfxTemplateManagerDlg UpdateDataTimer" );
+    m_aUpdateDataTimer.SetTimeout(EDIT_UPDATEDATA_TIMEOUT);
+}
+
+SfxTemplateManagerDlg::~SfxTemplateManagerDlg()
+{
+    writeSettings();
+
+    // Ignore view events since we are cleaning the object
+    mxLocalView->setItemStateHdl(Link<const ThumbnailViewItem*,void>());
+    mxLocalView->setOpenRegionHdl(Link<void*,void>());
+    mxLocalView->setOpenTemplateHdl(Link<ThumbnailViewItem*, void>());
+    mxSearchView->setItemStateHdl(Link<const ThumbnailViewItem*,void>());
+    mxSearchView->setOpenTemplateHdl(Link<ThumbnailViewItem*, void>());
+}
+
+short SfxTemplateManagerDlg::run()
+{
+    //use application specific settings if there's no previous setting
+    getApplicationSpecificSettings();
+    readSettings();
+
+    return weld::GenericDialogController::run();
+}
+
+IMPL_LINK(SfxTemplateManagerDlg, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
+{
+    if (mxSearchFilter != nullptr && !mxSearchFilter->get_text().isEmpty())
+    {
+        vcl::KeyCode    aKeyCode = rKeyEvent.GetKeyCode();
+        sal_uInt16      nKeyCode = aKeyCode.GetCode();
+
+        if ( nKeyCode == KEY_ESCAPE )
+        {
+            mxSearchFilter->set_text("");
+            SearchUpdateHdl(*mxSearchFilter);
+            return true;
+        }
+    }
+    return false;
+}
+
+void SfxTemplateManagerDlg::setDocumentModel(const uno::Reference<frame::XModel> &rModel)
+{
+    m_xModel = rModel;
+}
+
+FILTER_APPLICATION SfxTemplateManagerDlg::getCurrentApplicationFilter() const
+{
+    const sal_Int16 nCurAppId = mxCBApp->get_active();
+
+    if (nCurAppId == MNI_WRITER)
+        return FILTER_APPLICATION::WRITER;
+    else if (nCurAppId == MNI_IMPRESS)
+        return FILTER_APPLICATION::IMPRESS;
+    else if (nCurAppId == MNI_CALC)
+        return FILTER_APPLICATION::CALC;
+    else if (nCurAppId == MNI_DRAW)
+        return FILTER_APPLICATION::DRAW;
+
+    return FILTER_APPLICATION::NONE;
+}
+
+void SfxTemplateManagerDlg::fillFolderComboBox()
+{
+    std::vector<OUString> aFolderNames = mxLocalView->getFolderNames();
+
+    for (size_t i = 0, n = aFolderNames.size(); i < n; ++i)
+        mxCBFolder->append_text(aFolderNames[i]);
+    mxCBFolder->set_active(0);
+    mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, false);
+}
+
+void SfxTemplateManagerDlg::getApplicationSpecificSettings()
+{
+    if ( ! m_xModel.is() )
+    {
+        mxCBApp->set_active(0);
+        mxCBFolder->set_active(0);
+        mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, false);
+        mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter()));
+        mxLocalView->showAllTemplates();
+        return;
+    }
+
+    SvtModuleOptions::EFactory eFactory = SvtModuleOptions::ClassifyFactoryByModel(m_xModel);
+
+    switch(eFactory)
+    {
+        case SvtModuleOptions::EFactory::WRITER:
+        case SvtModuleOptions::EFactory::WRITERWEB:
+        case SvtModuleOptions::EFactory::WRITERGLOBAL:
+                            mxCBApp->set_active(MNI_WRITER);
+                            break;
+        case SvtModuleOptions::EFactory::CALC:
+                            mxCBApp->set_active(MNI_CALC);
+                            break;
+        case SvtModuleOptions::EFactory::IMPRESS:
+                            mxCBApp->set_active(MNI_IMPRESS);
+                            break;
+        case SvtModuleOptions::EFactory::DRAW:
+                            mxCBApp->set_active(MNI_DRAW);
+                            break;
+        default:
+                mxCBApp->set_active(0);
+                break;
+    }
+
+    mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter()));
+    mxCBFolder->set_active(0);
+    mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, false);
+    mxLocalView->showAllTemplates();
+}
+
+void SfxTemplateManagerDlg::readSettings ()
+{
+    OUString aLastFolder;
+    SvtViewOptions aViewSettings( EViewType::Dialog, TM_SETTING_MANAGER );
+
+    if ( aViewSettings.Exists() )
+    {
+        sal_uInt16 nTmp = 0;
+        aViewSettings.GetUserItem(TM_SETTING_LASTFOLDER) >>= aLastFolder;
+        aViewSettings.GetUserItem(TM_SETTING_LASTAPPLICATION) >>= nTmp;
+
+        //open last remembered application only when application model is not set
+        if(!m_xModel.is())
+        {
+            switch (nTmp)
+            {
+                case MNI_WRITER:
+                    mxCBApp->set_active(MNI_WRITER);
+                    break;
+                case MNI_CALC:
+                    mxCBApp->set_active(MNI_CALC);
+                    break;
+                case MNI_IMPRESS:
+                    mxCBApp->set_active(MNI_IMPRESS);
+                    break;
+                case MNI_DRAW:
+                    mxCBApp->set_active(MNI_DRAW);
+                    break;
+                default:
+                    mxCBApp->set_active(0);
+                    break;
+            }
+        }
+    }
+
+    mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter()));
+
+    if (aLastFolder.isEmpty())
+    {
+        //show all categories
+        mxCBFolder->set_active(0);
+        mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, false);
+        mxLocalView->showAllTemplates();
+    }
+    else
+    {
+        mxCBFolder->set_active_text(aLastFolder);
+        mxLocalView->showRegion(aLastFolder);
+        mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, true);
+    }
+}
+
+void SfxTemplateManagerDlg::writeSettings ()
+{
+    OUString aLastFolder;
+
+    if (mxLocalView->getCurRegionId())
+        aLastFolder = mxLocalView->getRegionName(mxLocalView->getCurRegionId()-1);
+
+    // last folder
+    Sequence< NamedValue > aSettings
+    {
+        { TM_SETTING_LASTFOLDER, css::uno::makeAny(aLastFolder) },
+        { TM_SETTING_LASTAPPLICATION,     css::uno::makeAny(sal_uInt16(mxCBApp->get_active())) }
+    };
+
+    // write
+    SvtViewOptions aViewSettings(EViewType::Dialog, TM_SETTING_MANAGER);
+    aViewSettings.SetUserData(aSettings);
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, SelectApplicationHdl, weld::ComboBox&, void)
+{
+    if (mxLocalView->IsVisible())
+    {
+        mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter()));
+        mxLocalView->showAllTemplates();
+        mxCBFolder->set_active(0);
+        mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, false);
+    }
+    if (mxSearchView->IsVisible())
+        SearchUpdate();
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, SelectRegionHdl, weld::ComboBox&, void)
+{
+    const OUString sSelectedRegion = mxCBFolder->get_active_text();
+
+    if(mxCBFolder->get_active() == 0)
+    {
+        mxLocalView->showAllTemplates();
+        mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, false);
+    }
+    else
+    {
+        mxLocalView->showRegion(sSelectedRegion);
+        mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, true);
+    }
+    if (mxSearchView->IsVisible())
+        SearchUpdate();
+}
+
+IMPL_LINK(SfxTemplateManagerDlg, TVItemStateHdl, const ThumbnailViewItem*, pItem, void)
+{
+    const TemplateViewItem *pViewItem = dynamic_cast<const TemplateViewItem*>(pItem);
+
+    if (pViewItem)
+        OnTemplateState(pItem);
+}
+
+IMPL_LINK(SfxTemplateManagerDlg, MenuSelectHdl, const OString&, rIdent, void)
+{
+    if (rIdent == MNI_ACTION_NEW_FOLDER)
+        OnCategoryNew();
+    else if (rIdent == MNI_ACTION_RENAME_FOLDER)
+        OnCategoryRename();
+    else if (rIdent == MNI_ACTION_DELETE_FOLDER)
+        OnCategoryDelete();
+    else if (rIdent == MNI_ACTION_REFRESH)
+        mxLocalView->reload();
+    else if (rIdent != MNI_ACTION_DEFAULT)
+        DefaultTemplateMenuSelectHdl(rIdent);
+}
+
+void SfxTemplateManagerDlg::DefaultTemplateMenuSelectHdl(const OString& rIdent)
+{
+    fprintf(stderr, "DefaultTemplateMenuSelectHdl ident %s\n", rIdent.getStr());
+
+    OUString aServiceName = SfxObjectShell::GetServiceNameFromFactory(OUString::fromUtf8(rIdent));
+
+    OUString sPrevDefault = SfxObjectFactory::GetStandardTemplate( aServiceName );
+    if(!sPrevDefault.isEmpty())
+        mxLocalView->RemoveDefaultTemplateIcon(sPrevDefault);
+
+    SfxObjectFactory::SetStandardTemplate( aServiceName, OUString() );
+
+    createDefaultTemplateMenu();
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, OkClickHdl, weld::Button&, void)
+{
+   OnTemplateOpen();
+   m_xDialog->response(RET_OK);
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, MoveClickHdl, weld::Button&, void)
+{
+    // modal dialog to select templates category
+    SfxTemplateCategoryDialog aDlg(m_xDialog.get());
+    aDlg.SetCategoryLBEntries(mxLocalView->getFolderNames());
+
+    size_t nItemId = 0;
+
+    if (aDlg.run() == RET_OK)
+    {
+        const OUString& sCategory = aDlg.GetSelectedCategory();
+        bool bIsNewCategory = aDlg.IsNewCategoryCreated();
+        if(bIsNewCategory)
+        {
+            if (!sCategory.isEmpty())
+            {
+                nItemId = mxLocalView->createRegion(sCategory);
+                if(nItemId)
+                    mxCBFolder->append_text(sCategory);
+            }
+        }
+        else
+            nItemId = mxLocalView->getRegionId(sCategory);
+    }
+
+    if(nItemId)
+    {
+        if (mxSearchView->IsVisible())
+            localSearchMoveTo(nItemId);
+        else
+            localMoveTo(nItemId);
+    }
+
+    mxLocalView->reload();
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, ExportClickHdl, weld::Button&, void)
+{
+    OnTemplateExport();
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, ImportClickHdl, weld::Button&, void)
+{
+    //Modal Dialog to select Category
+    SfxTemplateCategoryDialog aDlg(m_xDialog.get());
+    aDlg.SetCategoryLBEntries(mxLocalView->getFolderNames());
+
+    if (aDlg.run() == RET_OK)
+    {
+        const OUString& sCategory = aDlg.GetSelectedCategory();
+        bool bIsNewCategory = aDlg.IsNewCategoryCreated();
+        if(bIsNewCategory)
+        {
+            if(mxLocalView->createRegion(sCategory))
+            {
+                mxCBFolder->append_text(sCategory);
+                OnTemplateImportCategory(sCategory);
+            }
+            else
+            {
+                OUString aMsg( SfxResId(STR_CREATE_ERROR) );
+                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                          VclMessageType::Warning, VclButtonsType::Ok,
+                                                          aMsg.replaceFirst("$1", sCategory)));
+                xBox->run();
+                return;
+            }
+        }
+        else
+            OnTemplateImportCategory(sCategory);
+    }
+
+    mxLocalView->reload();
+    mxLocalView->showAllTemplates();
+    mxCBApp->set_active(0);
+    mxCBFolder->set_active(0);
+    mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, false);
+}
+
+IMPL_STATIC_LINK_NOARG(SfxTemplateManagerDlg, LinkClickHdl, weld::Button&, void)
+{
+    OnTemplateLink();
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, OpenRegionHdl, void*, void)
+{
+    maSelTemplates.clear();
+    mxOKButton->set_sensitive(false);
+    mxActionBar->show();
+}
+
+IMPL_LINK(SfxTemplateManagerDlg, CreateContextMenuHdl, ThumbnailViewItem*, pItem, void)
+{
+    const TemplateViewItem *pViewItem = dynamic_cast<TemplateViewItem*>(pItem);
+
+    if (pViewItem)
+    {
+        if (mxSearchView->IsVisible())
+            mxSearchView->createContextMenu(pViewItem->IsDefaultTemplate());
+        else
+            mxLocalView->createContextMenu(pViewItem->IsDefaultTemplate());
+    }
+}
+
+IMPL_LINK(SfxTemplateManagerDlg, OpenTemplateHdl, ThumbnailViewItem*, pItem, void)
+{
+    uno::Sequence< PropertyValue > aArgs(5);
+    aArgs[0].Name = "AsTemplate";
+    aArgs[0].Value <<= true;
+    aArgs[1].Name = "MacroExecutionMode";
+    aArgs[1].Value <<= MacroExecMode::USE_CONFIG;
+    aArgs[2].Name = "UpdateDocMode";
+    aArgs[2].Value <<= UpdateDocMode::ACCORDING_TO_CONFIG;
+    aArgs[3].Name = "InteractionHandler";
+    aArgs[3].Value <<= task::InteractionHandler::createWithParent( ::comphelper::getProcessComponentContext(), nullptr );
+    aArgs[4].Name = "ReadOnly";
+    aArgs[4].Value <<= true;
+
+    TemplateViewItem *pTemplateItem = static_cast<TemplateViewItem*>(pItem);
+
+    try
+    {
+        mxDesktop->loadComponentFromURL(pTemplateItem->getPath(),"_default", 0, aArgs );
+    }
+    catch( const uno::Exception& )
+    {
+    }
+
+    m_xDialog->response(RET_OK);
+}
+
+IMPL_LINK(SfxTemplateManagerDlg, EditTemplateHdl, ThumbnailViewItem*, pItem, void)
+{
+    uno::Sequence< PropertyValue > aArgs(3);
+    aArgs[0].Name = "AsTemplate";
+    aArgs[0].Value <<= false;
+    aArgs[1].Name = "MacroExecutionMode";
+    aArgs[1].Value <<= MacroExecMode::USE_CONFIG;
+    aArgs[2].Name = "UpdateDocMode";
+    aArgs[2].Value <<= UpdateDocMode::ACCORDING_TO_CONFIG;
+
+    uno::Reference< XStorable > xStorable;
+    TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(pItem);
+
+    try
+    {
+        xStorable.set( mxDesktop->loadComponentFromURL(pViewItem->getPath(),"_default", 0, aArgs ),
+                       uno::UNO_QUERY );
+    }
+    catch( const uno::Exception& )
+    {
+    }
+
+    m_xDialog->response(RET_OK);
+}
+
+IMPL_LINK(SfxTemplateManagerDlg, DeleteTemplateHdl, ThumbnailViewItem*, pItem, void)
+{
+    OUString aDeletedTemplate;
+    if(mxSearchView->IsVisible())
+    {
+        TemplateSearchViewItem *pSrchItem = static_cast<TemplateSearchViewItem*>(pItem);
+
+        if (!mxLocalView->removeTemplate(pSrchItem->mnAssocId, pSrchItem->mnRegionId))
+        {
+            aDeletedTemplate = pSrchItem->maTitle;
+        }
+    }
+    else
+    {
+        TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(pItem);
+        sal_uInt16 nRegionItemId = mxLocalView->getRegionId(pViewItem->mnRegionId);
+
+        if (!mxLocalView->removeTemplate(pViewItem->mnDocId + 1, nRegionItemId))//mnId w.r.t. region is mnDocId + 1;
+        {
+            aDeletedTemplate = pItem->maTitle;
+        }
+    }
+
+    if (!aDeletedTemplate.isEmpty())
+    {
+        OUString aMsg( SfxResId(STR_MSG_ERROR_DELETE_TEMPLATE) );
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                  VclMessageType::Warning, VclButtonsType::Ok,
+                                                  aMsg.replaceFirst("$1",aDeletedTemplate)));
+        xBox->run();
+    }
+}
+
+IMPL_LINK(SfxTemplateManagerDlg, DefaultTemplateHdl, ThumbnailViewItem*, pItem, void)
+{
+    TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(pItem);
+    OUString aServiceName;
+
+    if(!pViewItem->IsDefaultTemplate())
+    {
+        if (lcl_getServiceName(pViewItem->getPath(),aServiceName))
+        {
+            OUString sPrevDefault = SfxObjectFactory::GetStandardTemplate( aServiceName );
+            if(!sPrevDefault.isEmpty())
+                mxLocalView->RemoveDefaultTemplateIcon(sPrevDefault);
+
+            SfxObjectFactory::SetStandardTemplate(aServiceName,pViewItem->getPath());
+            pViewItem->showDefaultIcon(true);
+        }
+    }
+    else
+    {
+        if(lcl_getServiceName(pViewItem->getPath(),aServiceName))
+        {
+            SfxObjectFactory::SetStandardTemplate( aServiceName, OUString() );
+            pViewItem->showDefaultIcon(false);
+        }
+    }
+
+    createDefaultTemplateMenu();
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, SearchUpdateHdl, weld::Entry&, void)
+{
+    m_aUpdateDataTimer.Start();
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, ImplUpdateDataHdl, Timer*, void)
+{
+    SearchUpdate();
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, LoseFocusHdl, weld::Widget&, void)
+{
+    if (m_aUpdateDataTimer.IsActive())
+    {
+        m_aUpdateDataTimer.Stop();
+        m_aUpdateDataTimer.Invoke();
+    }
+}
+
+void SfxTemplateManagerDlg::SearchUpdate()
+{
+    OUString aKeyword = mxSearchFilter->get_text();
+
+    if (!aKeyword.isEmpty())
+    {
+        mxSearchView->Clear();
+
+        // if the search view is hidden, hide the folder view and display search one
+        if (!mxSearchView->IsVisible())
+        {
+            mxLocalView->deselectItems();
+            mxSearchView->Show();
+            mxLocalView->Hide();
+        }
+
+        std::vector<TemplateItemProperties> aItems =
+                mxLocalView->getFilteredItems(SearchView_Keyword(aKeyword, getCurrentApplicationFilter()));
+
+        for (const TemplateItemProperties& rItem : aItems)
+        {
+            OUString aFolderName = mxLocalView->getRegionName(rItem.nRegionId);
+
+            mxSearchView->AppendItem(rItem.nId,mxLocalView->getRegionId(rItem.nRegionId),
+                                     rItem.nDocId,
+                                     rItem.aName,
+                                     aFolderName,
+                                     rItem.aPath,
+                                     rItem.aThumbnail);
+        }
+
+        mxSearchView->Invalidate();
+    }
+    else
+    {
+        mxSearchView->deselectItems();
+        mxSearchView->Hide();
+        mxLocalView->Show();
+        mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter()));
+        mxLocalView->reload();
+        OUString sLastFolder = mxCBFolder->get_active_text();
+        mxLocalView->showRegion(sLastFolder);
+        mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, true);
+    }
+}
+
+IMPL_LINK_NOARG(SfxTemplateManagerDlg, GetFocusHdl, weld::Widget&, void)
+{
+    mxLocalView->deselectItems();
+    mxSearchView->deselectItems();
+
+    maSelTemplates.clear();
+}
+
+void SfxTemplateManagerDlg::OnTemplateState (const ThumbnailViewItem *pItem)
+{
+    bool bInSelection = maSelTemplates.find(pItem) != maSelTemplates.end();
+
+    if (pItem->isSelected())
+    {
+        if (maSelTemplates.empty())
+        {
+            mxOKButton->set_sensitive(true);
+        }
+        else if (maSelTemplates.size() != 1 || !bInSelection)
+        {
+            mxOKButton->set_sensitive(false);
+        }
+
+        if (!bInSelection)
+            maSelTemplates.insert(pItem);
+    }
+    else
+    {
+        if (bInSelection)
+        {
+            maSelTemplates.erase(pItem);
+
+            if (maSelTemplates.empty())
+            {
+                mxOKButton->set_sensitive(false);
+            }
+            else if (maSelTemplates.size() == 1)
+            {
+                mxOKButton->set_sensitive(true);
+            }
+        }
+    }
+
+    if(maSelTemplates.empty())
+    {
+        mxMoveButton->set_sensitive(false);
+        mxExportButton->set_sensitive(false);
+    }
+    else
+    {
+        mxMoveButton->set_sensitive(true);
+        mxExportButton->set_sensitive(true);
+    }
+}
+
+void SfxTemplateManagerDlg::OnTemplateImportCategory(const OUString& sCategory)
+{
+    sfx2::FileDialogHelper aFileDlg(css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE,
+                                    FileDialogFlags::MultiSelection, m_xDialog.get());
+
+    // add "All" filter
+    aFileDlg.AddFilter( SfxResId(STR_SFX_FILTERNAME_ALL),
+                        FILEDIALOG_FILTER_ALL );
+
+    // add template filter
+    OUString sFilterExt;
+    OUString sFilterName( SfxResId( STR_TEMPLATE_FILTER ) );
+
+    // add filters of modules which are installed
+    SvtModuleOptions aModuleOpt;
+    if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::WRITER ) )
+        sFilterExt += "*.ott;*.stw;*.oth;*.dotx;*.dot";
+
+    if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::CALC ) )
+    {
+        if ( !sFilterExt.isEmpty() )
+            sFilterExt += ";";
+
+        sFilterExt += "*.ots;*.stc;*.xltx;*.xlt";
+    }
+
+    if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::IMPRESS ) )
+    {
+        if ( !sFilterExt.isEmpty() )
+            sFilterExt += ";";
+
+        sFilterExt += "*.otp;*.sti;*.pot;*.potx";
+    }
+
+    if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::DRAW ) )
+    {
+        if ( !sFilterExt.isEmpty() )
+            sFilterExt += ";";
+
+        sFilterExt += "*.otg;*.std";
+    }
+
+    if ( !sFilterExt.isEmpty() )
+        sFilterExt += ";";
+
+    sFilterExt += "*.vor";
+
+    sFilterName += " (" + sFilterExt + ")";
+
+    aFileDlg.AddFilter( sFilterName, sFilterExt );
+    aFileDlg.SetCurrentFilter( sFilterName );
+
+    ErrCode nCode = aFileDlg.Execute();
+
+    if ( nCode != ERRCODE_NONE )
+        return;
+
+    const css::uno::Sequence<OUString> aFiles = aFileDlg.GetSelectedFiles();
+
+    if (!aFiles.hasElements())
+        return;
+
+    //Import to the selected regions
+    TemplateContainerItem* pContItem = mxLocalView->getRegion(sCategory);
+    if(!pContItem)
+        return;
+
+    OUString aTemplateList;
+
+    for (const auto& rFile : aFiles)
+    {
+        if(!mxLocalView->copyFrom(pContItem, rFile))
+        {
+            if (aTemplateList.isEmpty())
+                aTemplateList = rFile;
+            else
+                aTemplateList += "\n" + rFile;
+        }
+    }
+
+    if (!aTemplateList.isEmpty())
+    {
+        OUString aMsg(SfxResId(STR_MSG_ERROR_IMPORT));
+        aMsg = aMsg.replaceFirst("$1",pContItem->maTitle);
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                  VclMessageType::Warning, VclButtonsType::Ok,
+                                                  aMsg.replaceFirst("$2",aTemplateList)));
+        xBox->run();
+    }
+}
+
+void SfxTemplateManagerDlg::OnTemplateExport()
+{
+    uno::Reference<XComponentContext> xContext(comphelper::getProcessComponentContext());
+    uno::Reference<XFolderPicker2> xFolderPicker = FolderPicker::create(xContext);
+
+    xFolderPicker->setDisplayDirectory(SvtPathOptions().GetWorkPath());
+
+    sal_Int16 nResult = xFolderPicker->execute();
+    sal_Int16 nCount = maSelTemplates.size();
+
+    if( nResult != ExecutableDialogResults::OK )
+        return;
+
+    OUString aTemplateList;
+    INetURLObject aPathObj(xFolderPicker->getDirectory());
+    aPathObj.setFinalSlash();
+
+    if (mxSearchView->IsVisible())
+    {
+        sal_uInt16 i = 1;
+
+        for (auto const& selTemplate : maSelTemplates)
+        {
+            const TemplateSearchViewItem *pItem = static_cast<const TemplateSearchViewItem*>(selTemplate);
+
+            INetURLObject aItemPath(pItem->getPath());
+
+            if ( 1 == i )
+                aPathObj.Append(aItemPath.getName());
+            else
+                aPathObj.setName(aItemPath.getName());
+
+            OUString aPath = aPathObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+            if (!mxLocalView->exportTo(pItem->mnAssocId,pItem->mnRegionId,aPath))
+            {
+                if (aTemplateList.isEmpty())
+                    aTemplateList = pItem->maTitle;
+                else
+                    aTemplateList += "\n" + pItem->maTitle;
+            }
+            ++i;
+        }
+
+        mxSearchView->deselectItems();
+    }
+    else
+    {
+        // export templates from the current view
+
+        sal_uInt16 i = 1;
+
+        for (auto const& selTemplate : maSelTemplates)
+        {
+            const TemplateViewItem *pItem = static_cast<const TemplateViewItem*>(selTemplate);
+
+            INetURLObject aItemPath(pItem->getPath());
+
+            if ( 1 == i )
+                aPathObj.Append(aItemPath.getName());
+            else
+                aPathObj.setName(aItemPath.getName());
+
+            OUString aPath = aPathObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+            if (!mxLocalView->exportTo(pItem->mnDocId + 1,   //mnId w.r.t. region = mDocId + 1
+                mxLocalView->getRegionId(pItem->mnRegionId), //pItem->mnRegionId does not store actual region Id
+                aPath))
+            {
+                if (aTemplateList.isEmpty())
+                    aTemplateList = pItem->maTitle;
+                else
+                    aTemplateList += "\n" + pItem->maTitle;
+            }
+            ++i;
+        }
+
+        mxLocalView->deselectItems();
+    }
+
+    if (!aTemplateList.isEmpty())
+    {
+        OUString aText( SfxResId(STR_MSG_ERROR_EXPORT) );
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                  VclMessageType::Warning, VclButtonsType::Ok,
+                                                  aText.replaceFirst("$1",aTemplateList)));
+        xBox->run();
+    }
+    else
+    {
+        OUString sText( SfxResId(STR_MSG_EXPORT_SUCCESS) );
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                  VclMessageType::Info, VclButtonsType::Ok,
+                                                  sText.replaceFirst("$1", OUString::number(nCount))));
+        xBox->run();
+    }
+}
+
+void SfxTemplateManagerDlg::OnTemplateLink ()
+{
+    OUString sNodePath("/org.openoffice.Office.Common/Help/StartCenter");
+    try
+    {
+        Reference<lang::XMultiServiceFactory> xConfig = configuration::theDefaultProvider::get( comphelper::getProcessComponentContext() );
+        uno::Sequence<uno::Any> args(comphelper::InitAnyPropertySequence(
+        {
+            {"nodepath", uno::Any(sNodePath)}
+        }));
+        Reference<container::XNameAccess> xNameAccess(xConfig->createInstanceWithArguments("com.sun.star.configuration.ConfigurationAccess", args), UNO_QUERY);
+        if( xNameAccess.is() )
+        {
+            OUString sURL;
+            //throws css::container::NoSuchElementException, css::lang::WrappedTargetException
+            Any value( xNameAccess->getByName("TemplateRepositoryURL") );
+            sURL = value.get<OUString> ();
+            localizeWebserviceURI(sURL);
+
+            Reference< css::system::XSystemShellExecute > xSystemShellExecute(
+                css::system::SystemShellExecute::create(comphelper::getProcessComponentContext()));
+            xSystemShellExecute->execute( sURL, OUString(), css::system::SystemShellExecuteFlags::URIS_ONLY);
+        }
+    }
+    catch (const Exception&)
+    {
+    }
+}
+
+void SfxTemplateManagerDlg::OnTemplateOpen ()
+{
+    ThumbnailViewItem *pItem = const_cast<ThumbnailViewItem*>(*maSelTemplates.begin());
+
+    OpenTemplateHdl(pItem);
+}
+
+void SfxTemplateManagerDlg::OnCategoryNew()
+{
+    InputDialog dlg(m_xDialog.get(), SfxResId(STR_INPUT_NEW));
+
+    int ret = dlg.run();
+
+    if (!ret)
+        return;
+
+    OUString aName = dlg.GetEntryText();
+
+    if(mxLocalView->createRegion(aName))
+        mxCBFolder->append_text(aName);
+    else
+    {
+        OUString aMsg( SfxResId(STR_CREATE_ERROR) );
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                  VclMessageType::Warning, VclButtonsType::Ok,
+                                                  aMsg.replaceFirst("$1", aName)));
+        xBox->run();
+    }
+}
+
+void SfxTemplateManagerDlg::OnCategoryRename()
+{
+    OUString sCategory = mxCBFolder->get_active_text();
+    InputDialog dlg(m_xDialog.get(), SfxResId(STR_INPUT_NEW));
+
+    dlg.SetEntryText(sCategory);
+    int ret = dlg.run();
+
+    if (!ret)
+        return;
+
+    OUString aName = dlg.GetEntryText();
+
+    if(mxLocalView->renameRegion(sCategory, aName))
+    {
+        sal_Int32 nPos = mxCBFolder->find_text(sCategory);
+        mxCBFolder->remove(nPos);
+        mxCBFolder->insert_text(nPos, aName);
+        mxCBFolder->set_active(nPos);
+
+        mxLocalView->reload();
+        mxLocalView->showRegion(aName);
+    }
+    else
+    {
+        OUString aMsg( SfxResId(STR_CREATE_ERROR) );
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                  VclMessageType::Warning, VclButtonsType::Ok,
+                                                  aMsg.replaceFirst("$1", aName)));
+        xBox->run();
+    }
+}
+
+void SfxTemplateManagerDlg::OnCategoryDelete()
+{
+    SfxTemplateCategoryDialog aDlg(m_xDialog.get());
+    aDlg.SetCategoryLBEntries(mxLocalView->getFolderNames());
+    aDlg.HideNewCategoryOption();
+    aDlg.set_title(SfxResId(STR_CATEGORY_DELETE));
+    aDlg.SetSelectLabelText(SfxResId(STR_CATEGORY_SELECT));
+
+    if (aDlg.run() == RET_OK)
+    {
+        const OUString& sCategory = aDlg.GetSelectedCategory();
+        std::unique_ptr<weld::MessageDialog> popupDlg(Application::CreateMessageDialog(m_xDialog.get(),
+                                                      VclMessageType::Question, VclButtonsType::YesNo,
+                                                      SfxResId(STR_QMSG_SEL_FOLDER_DELETE)));
+        if (popupDlg->run() != RET_YES)
+            return;
+
+        sal_Int16 nItemId = mxLocalView->getRegionId(sCategory);
+
+        if (!mxLocalView->removeRegion(nItemId))
+        {
+            OUString sMsg( SfxResId(STR_MSG_ERROR_DELETE_FOLDER) );
+            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                      VclMessageType::Warning, VclButtonsType::Ok,
+                                                      sMsg.replaceFirst("$1",sCategory)));
+            xBox->run();
+        }
+        else
+        {
+            mxCBFolder->remove_text(sCategory);
+        }
+    }
+
+    mxLocalView->reload();
+    mxLocalView->showAllTemplates();
+    mxCBApp->set_active(0);
+    mxCBFolder->set_active(0);
+    mxActionBar->set_item_visible(MNI_ACTION_RENAME_FOLDER, false);
+}
+
+void SfxTemplateManagerDlg::createDefaultTemplateMenu ()
+{
+    std::vector<OUString> aList = lcl_getAllFactoryURLs();
+
+    if (!aList.empty())
+    {
+        mxTemplateDefaultMenu->clear();
+
+        for (auto const& elem : aList)
+        {
+            INetURLObject aObj(elem);
+            OUString aTitle = SvFileInformationManager::GetDescription(aObj);
+            mxTemplateDefaultMenu->append(elem, aTitle, SvFileInformationManager::GetImageId(aObj));
+        }
+
+        mxActionBar->set_item_visible(MNI_ACTION_DEFAULT, true);
+    }
+    else
+        mxActionBar->set_item_visible(MNI_ACTION_DEFAULT, false);
+}
+
+void SfxTemplateManagerDlg::localMoveTo(sal_uInt16 nItemId)
+{
+    if (nItemId)
+    {
+        // Move templates to desired folder if for some reason move fails
+        // try copying them.
+        mxLocalView->moveTemplates(maSelTemplates,nItemId);
+    }
+}
+
+void SfxTemplateManagerDlg::localSearchMoveTo(sal_uInt16 nItemId)
+{
+    if (nItemId)
+    {
+        // Move templates to desired folder if for some reason move fails
+        // try copying them.
+        std::set<const ThumbnailViewItem*,selection_cmp_fn> aSelTemplates = maSelTemplates; //Copy to avoid invalidating an iterator
+
+        for (auto const& selTemplate : aSelTemplates)
+        {
+            const TemplateSearchViewItem *pItem =
+                    static_cast<const TemplateSearchViewItem*>(selTemplate);
+
+            if(!mxLocalView->moveTemplate(pItem,pItem->mnRegionId,nItemId))
+            {
+                OUString sDst = mxLocalView->getRegionItemName(nItemId);
+                OUString sMsg(SfxResId(STR_MSG_ERROR_LOCAL_MOVE));
+                sMsg = sMsg.replaceFirst("$1",sDst);
+                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                          VclMessageType::Warning, VclButtonsType::Ok,
+                                                          sMsg.replaceFirst( "$2",pItem->maTitle)));
+                xBox->run();
+            }
+        }
+    }
+
+    // Deselect all items and update search results
+    mxSearchView->deselectItems();
+
+    SearchUpdateHdl(*mxSearchFilter);
+}
+
+static bool lcl_getServiceName ( const OUString &rFileURL, OUString &rName )
+{
+    bool bRet = false;
+
+    if ( !rFileURL.isEmpty() )
+    {
+        try
+        {
+            uno::Reference< embed::XStorage > xStorage =
+                    comphelper::OStorageHelper::GetStorageFromURL( rFileURL, embed::ElementModes::READ );
+
+            SotClipboardFormatId nFormat = SotStorage::GetFormatID( xStorage );
+
+            std::shared_ptr<const SfxFilter> pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4ClipBoardId( nFormat );
+
+            if ( pFilter )
+            {
+                rName = pFilter->GetServiceName();
+                bRet = true;
+            }
+        }
+        catch( uno::Exception& )
+        {}
+    }
+
+    return bRet;
+}
+
+static std::vector<OUString> lcl_getAllFactoryURLs ()
+{
+    SvtModuleOptions aModOpt;
+    std::vector<OUString> aList;
+    const css::uno::Sequence<OUString> &aServiceNames = aModOpt.GetAllServiceNames();
+
+    for( const auto& rServiceName : aServiceNames )
+    {
+        if ( ! SfxObjectFactory::GetStandardTemplate( rServiceName ).isEmpty() )
+        {
+            SvtModuleOptions::EFactory eFac = SvtModuleOptions::EFactory::WRITER;
+            SvtModuleOptions::ClassifyFactoryByName( rServiceName, eFac );
+            aList.push_back(aModOpt.GetFactoryEmptyDocumentURL(eFac));
+        }
+    }
+
+    return aList;
+}
+
+
+//   Class SfxTemplateCategoryDialog --------------------------------------------------
+
+SfxTemplateCategoryDialog::SfxTemplateCategoryDialog(weld::Window* pParent)
+    : GenericDialogController(pParent, "sfx/ui/templatecategorydlg.ui", "TemplatesCategoryDialog")
+    , msSelectedCategory(OUString())
+    , mbIsNewCategory(false)
+    , mxLBCategory(m_xBuilder->weld_tree_view("categorylb"))
+    , mxSelectLabel(m_xBuilder->weld_label("select_label"))
+    , mxNewCategoryEdit(m_xBuilder->weld_entry("category_entry"))
+    , mxCreateLabel(m_xBuilder->weld_label("create_label"))
+    , mxOKButton(m_xBuilder->weld_button("ok"))
+{
+    mxLBCategory->append_text(SfxResId(STR_CATEGORY_NONE));
+    mxNewCategoryEdit->connect_changed(LINK(this, SfxTemplateCategoryDialog, NewCategoryEditHdl));
+    mxLBCategory->set_size_request(mxLBCategory->get_approximate_digit_width() * 32,
+                                   mxLBCategory->get_height_rows(8));
+    mxLBCategory->connect_changed(LINK(this, SfxTemplateCategoryDialog, SelectCategoryHdl));
+    mxOKButton->set_sensitive(false);
+}
+
+SfxTemplateCategoryDialog::~SfxTemplateCategoryDialog()
+{
+}
+
+IMPL_LINK_NOARG(SfxTemplateCategoryDialog, NewCategoryEditHdl, weld::Entry&, void)
+{
+    OUString sParam = comphelper::string::strip(mxNewCategoryEdit->get_text(), ' ');
+    mxLBCategory->set_sensitive(sParam.isEmpty());
+    if(!sParam.isEmpty())
+    {
+        msSelectedCategory = sParam;
+        mbIsNewCategory = true;
+        mxOKButton->set_sensitive(true);
+    }
+    else
+    {
+        SelectCategoryHdl(*mxLBCategory);
+        mbIsNewCategory = false;
+    }
+}
+
+IMPL_LINK_NOARG(SfxTemplateCategoryDialog, SelectCategoryHdl, weld::TreeView&, void)
+{
+    if (mxLBCategory->get_selected_index() == 0)
+    {
+        msSelectedCategory = OUString();
+        mxOKButton->set_sensitive(false);
+        mxNewCategoryEdit->set_sensitive(true);
+    }
+    else
+    {
+        msSelectedCategory = mxLBCategory->get_selected_text();
+        mxNewCategoryEdit->set_sensitive(false);
+        mxOKButton->set_sensitive(true);
+    }
+
+    mbIsNewCategory = false;
+}
+
+void SfxTemplateCategoryDialog::SetCategoryLBEntries(std::vector<OUString> aFolderNames)
+{
+    for (size_t i = 0, n = aFolderNames.size(); i < n; ++i)
+        mxLBCategory->append_text(aFolderNames[i]);
+    mxLBCategory->select(0);
+}
+
+void SfxTemplateCategoryDialog::HideNewCategoryOption()
+{
+    mxCreateLabel->hide();
+    mxNewCategoryEdit->hide();
+}
+
+// SfxTemplateSelectionDialog -----------------------------------------------------------------
+
+SfxTemplateSelectionDlg::SfxTemplateSelectionDlg(weld::Window* pParent)
+    : SfxTemplateManagerDlg(pParent)
+    , msTemplatePath(OUString())
+{
+    mxCBApp->set_active(MNI_IMPRESS);
+    mxCBFolder->set_active(0);
+    m_xDialog->set_title(SfxResId(STR_TEMPLATE_SELECTION));
+
+    if (mxLocalView->IsVisible())
+    {
+        mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter()));
+        mxLocalView->showAllTemplates();
+    }
+
+    mxCBApp->set_sensitive(false);
+    mxActionBar->hide();
+    mxLinkButton->hide();
+    mxMoveButton->hide();
+    mxExportButton->hide();
+    mxCBXHideDlg->show();
+    mxCBXHideDlg->set_active(true);
+
+    mxLocalView->setOpenTemplateHdl(LINK(this,SfxTemplateSelectionDlg, OpenTemplateHdl));
+    mxSearchView->setOpenTemplateHdl(LINK(this,SfxTemplateSelectionDlg, OpenTemplateHdl));
+
+    mxSearchView->SetMultiSelectionEnabled(false);
+
+    mxOKButton->connect_clicked(LINK(this, SfxTemplateSelectionDlg, OkClickHdl));
+}
+
+SfxTemplateSelectionDlg::~SfxTemplateSelectionDlg()
+{
+    maIdle.Stop();
+}
+
+short SfxTemplateSelectionDlg::run()
+{
+    // tdf#124597 at startup this dialog is launched before its parent window
+    // has taken its final size. The parent size request is processed during
+    // the dialogs event loop so configure this dialog to center to
+    // the parents pending geometry request
+    m_xDialog->set_centered_on_parent(true);
+
+    // tdf#125079 toggle off the size tracking at some future idle point
+    maIdle.SetPriority(TaskPriority::LOWEST);
+    maIdle.SetInvokeHandler(LINK(this,SfxTemplateSelectionDlg,TimeOut));
+    maIdle.Start();
+
+    return weld::GenericDialogController::run();
+}
+
+IMPL_LINK_NOARG(SfxTemplateSelectionDlg, TimeOut, Timer*, void)
+{
+    m_xDialog->set_centered_on_parent(false);
+}
+
+IMPL_LINK(SfxTemplateSelectionDlg, OpenTemplateHdl, ThumbnailViewItem*, pItem, void)
+{
+    TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(pItem);
+    msTemplatePath = pViewItem->getPath();
+
+    m_xDialog->response(RET_OK);
+}
+
+IMPL_LINK_NOARG(SfxTemplateSelectionDlg, OkClickHdl, weld::Button&, void)
+{
+   TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(const_cast<ThumbnailViewItem*>(*maSelTemplates.begin()));
+   msTemplatePath = pViewItem->getPath();
+
+   m_xDialog->response(RET_OK);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */