cui/source/customize/SvxNotebookbarConfigPage.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <vcl/commandinfoprovider.hxx>
  23 #include <vcl/event.hxx>
  24 #include <vcl/weld.hxx>
  25 #include <vcl/svapp.hxx>
  26
  27 #include <algorithm>
  28 #include <cstddef>
  29
  30 #include <helpids.h>
  31 #include <strings.hrc>
  32
  33 #include <cfg.hxx>
  34 #include <SvxNotebookbarConfigPage.hxx>
  35 #include <SvxConfigPageHelper.hxx>
  36 #include <dialmgr.hxx>
  37 #include <libxml/parser.h>
  38 #include <osl/file.hxx>
  39 #include <CustomNotebookbarGenerator.hxx>
  40 #include <sfx2/notebookbar/SfxNotebookBar.hxx>
  41 #include <unotools/configmgr.hxx>
  42 #include <comphelper/processfactory.hxx>
  43 #include <com/sun/star/frame/theUICommandDescription.hpp>
  44 #include <com/sun/star/ui/ImageType.hpp>
  45
  46 namespace uno = com::sun::star::uno;
  47 namespace frame = com::sun::star::frame;
  48 namespace lang = com::sun::star::lang;
  49 namespace container = com::sun::star::container;
  50 namespace beans = com::sun::star::beans;
  51 namespace graphic = com::sun::star::graphic;
  52
  53 static bool isCategoryAvailable(const OUString& sClassId, const OUString& sUIItemId,
  54                                 const OUString& sActiveCategory, bool& isCategory)
  55 {
  56     if (sUIItemId == sActiveCategory)
  57         return true;
  58     else if ((sClassId == "GtkMenu" || sClassId == "GtkGrid") && sUIItemId != sActiveCategory)
  59     {
  60         isCategory = false;
  61         return false;
  62     }
  63     return false;
  64 }
  65
  66 static OUString charToString(const char* cString)
  67 {
  68     OUStringBuffer aString;
  69     for (std::size_t i = 0; i < strlen(cString); i++)
  70     {
  71         aString.append(cString[i]);
  72     }
  73     return aString.makeStringAndClear();
  74 }
  75
  76 static OUString getFileName(const OUString& aFileName)
  77 {
  78     if (aFileName == "notebookbar.ui")
  79         return "Tabbed";
  80     else if (aFileName == "notebookbar_compact.ui")
  81         return "TabbedCompact";
  82     else if (aFileName == "notebookbar_groupedbar_full.ui")
  83         return "Groupedbar";
  84     else if (aFileName == "notebookbar_groupedbar_compact.ui")
  85         return "GroupedbarCompact";
  86     else
  87         return "None";
  88 }
  89
  90 static OUString getModuleId(const OUString& sModuleName)
  91 {
  92     if (sModuleName == "Writer")
  93         return "com.sun.star.text.TextDocument";
  94     else if (sModuleName == "Draw")
  95         return "com.sun.star.drawing.DrawingDocument";
  96     else if (sModuleName == "Impress")
  97         return "com.sun.star.presentation.PresentationDocument";
  98     else if (sModuleName == "Calc")
  99         return "com.sun.star.sheet.SpreadsheetDocument";
 100     else
 101         return "None";
 102 }
 103
 104 SvxNotebookbarConfigPage::SvxNotebookbarConfigPage(weld::Container* pPage,
 105                                                    weld::DialogController* pController,
 106                                                    const SfxItemSet& rSet)
 107     : SvxConfigPage(pPage, pController, rSet)
 108 {
 109     m_xCommandCategoryListBox->set_visible(false);
 110     m_xDescriptionFieldLb->set_visible(false);
 111     m_xSearchEdit->set_visible(false);
 112     m_xDescriptionField->set_visible(false);
 113     m_xMoveUpButton->set_visible(false);
 114     m_xMoveDownButton->set_visible(false);
 115     m_xAddCommandButton->set_visible(false);
 116     m_xRemoveCommandButton->set_visible(false);
 117     m_xLeftFunctionLabel->set_visible(false);
 118     m_xSearchLabel->set_visible(false);
 119     m_xCategoryLabel->set_visible(false);
 120     m_xInsertBtn->set_visible(false);
 121     m_xModifyBtn->set_visible(false);
 122     m_xResetBtn->set_visible(false);
 123     m_xCustomizeLabel->set_visible(false);
 124
 125     weld::TreeView& rCommandCategoryBox = m_xFunctions->get_widget();
 126     rCommandCategoryBox.hide();
 127
 128     m_xContentsListBox.reset(
 129         new SvxNotebookbarEntriesListBox(m_xBuilder->weld_tree_view("toolcontents"), this));
 130     std::vector<int> aWidths;
 131     weld::TreeView& rTreeView = m_xContentsListBox->get_widget();
 132     Size aSize(m_xFunctions->get_size_request());
 133     rTreeView.set_size_request(aSize.Width(), aSize.Height());
 134
 135     int nExpectedSize = 16;
 136
 137     int nStandardImageColWidth = rTreeView.get_checkbox_column_width();
 138     int nMargin = nStandardImageColWidth - nExpectedSize;
 139     if (nMargin < 16)
 140         nMargin = 16;
 141
 142     if (SvxConfigPageHelper::GetImageType() & css::ui::ImageType::SIZE_LARGE)
 143         nExpectedSize = 24;
 144     else if (SvxConfigPageHelper::GetImageType() & css::ui::ImageType::SIZE_32)
 145         nExpectedSize = 32;
 146
 147     int nImageColWidth = nExpectedSize + nMargin;
 148
 149     aWidths.push_back(nStandardImageColWidth);
 150     aWidths.push_back(nImageColWidth);
 151     rTreeView.set_column_fixed_widths(aWidths);
 152
 153     rTreeView.set_hexpand(true);
 154     rTreeView.set_vexpand(true);
 155     rTreeView.set_help_id(HID_SVX_CONFIG_NOTEBOOKBAR_CONTENTS);
 156     rTreeView.show();
 157 }
 158
 159 SvxNotebookbarConfigPage::~SvxNotebookbarConfigPage() {}
 160
 161 void SvxNotebookbarConfigPage::DeleteSelectedTopLevel() {}
 162
 163 void SvxNotebookbarConfigPage::DeleteSelectedContent() {}
 164
 165 void SvxNotebookbarConfigPage::Init()
 166 {
 167     m_xTopLevelListBox->clear();
 168     m_xContentsListBox->clear();
 169     m_xSaveInListBox->clear();
 170     CustomNotebookbarGenerator::createCustomizedUIFile();
 171     OUString sAppName, sFileName;
 172     CustomNotebookbarGenerator::getFileNameAndAppName(sAppName, sFileName);
 173     OUString sNotebookbarInterface = getFileName(sFileName);
 174
 175     OUString sScopeName
 176         = utl::ConfigManager::getProductName() + " " + sAppName + " -  " + sNotebookbarInterface;
 177     OUString sSaveInListBoxID = notebookbarTabScope;
 178
 179     m_xSaveInListBox->append(sSaveInListBoxID, sScopeName);
 180     m_xSaveInListBox->set_active_id(sSaveInListBoxID);
 181
 182     m_xTopLevelListBox->append("NotebookBar", "All Commands");
 183     m_xTopLevelListBox->set_active_id("NotebookBar");
 184     SelectElement();
 185 }
 186
 187 SaveInData* SvxNotebookbarConfigPage::CreateSaveInData(
 188     const css::uno::Reference<css::ui::XUIConfigurationManager>& xCfgMgr,
 189     const css::uno::Reference<css::ui::XUIConfigurationManager>& xParentCfgMgr,
 190     const OUString& aModuleId, bool bDocConfig)
 191 {
 192     return static_cast<SaveInData*>(
 193         new ToolbarSaveInData(xCfgMgr, xParentCfgMgr, aModuleId, bDocConfig));
 194 }
 195
 196 void SvxNotebookbarConfigPage::UpdateButtonStates() {}
 197
 198 short SvxNotebookbarConfigPage::QueryReset()
 199 {
 200     OUString msg = CuiResId(RID_SVXSTR_CONFIRM_TOOLBAR_RESET);
 201
 202     OUString saveInName = m_xSaveInListBox->get_active_text();
 203
 204     OUString label = SvxConfigPageHelper::replaceSaveInName(msg, saveInName);
 205
 206     std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(
 207         GetFrameWeld(), VclMessageType::Question, VclButtonsType::YesNo, label));
 208     int nValue = xQueryBox->run();
 209     if (nValue == RET_YES)
 210     {
 211         OUString sOriginalUIPath = CustomNotebookbarGenerator::getOriginalUIPath();
 212         OUString sCustomizedUIPath = CustomNotebookbarGenerator::getCustomizedUIPath();
 213         osl::File::copy(sOriginalUIPath, sCustomizedUIPath);
 214         OUString sAppName, sFileName;
 215         CustomNotebookbarGenerator::getFileNameAndAppName(sAppName, sFileName);
 216         OUString sNotebookbarInterface = getFileName(sFileName);
 217         Sequence<OUString> sSequenceEntries;
 218         CustomNotebookbarGenerator::setCustomizedUIItem(sSequenceEntries, sNotebookbarInterface);
 219         OUString sUIPath = "modules/s" + sAppName.toAsciiLowerCase() + "/ui/";
 220         sfx2::SfxNotebookBar::ReloadNotebookBar(sUIPath);
 221     }
 222     return nValue;
 223 }
 224
 225 void SvxConfigPage::InsertEntryIntoNotebookbarTabUI(const OUString& sClassId,
 226                                                     const OUString& sUIItemId,
 227                                                     const OUString& sUIItemCommand, int nPos,
 228                                                     int nStartCol)
 229 {
 230     OUString sAppName, sFileName;
 231     CustomNotebookbarGenerator::getFileNameAndAppName(sAppName, sFileName);
 232
 233     css::uno::Reference<css::container::XNameAccess> m_xCommandToLabelMap,
 234         m_xGlobalCommandToLabelMap;
 235     uno::Reference<uno::XComponentContext> xContext = ::comphelper::getProcessComponentContext();
 236     uno::Reference<container::XNameAccess> xNameAccess(
 237         css::frame::theUICommandDescription::get(xContext));
 238
 239     uno::Sequence<beans::PropertyValue> aPropSeq, aGlobalPropSeq;
 240
 241     xNameAccess->getByName("com.sun.star.text.GlobalDocument") >>= m_xGlobalCommandToLabelMap;
 242     xNameAccess->getByName(getModuleId(sAppName)) >>= m_xCommandToLabelMap;
 243
 244     try
 245     {
 246         uno::Any aModuleVal = m_xCommandToLabelMap->getByName(sUIItemCommand);
 247
 248         aModuleVal >>= aPropSeq;
 249     }
 250     catch (container::NoSuchElementException&)
 251     {
 252     }
 253
 254     try
 255     {
 256         uno::Any aGlobalVal = m_xGlobalCommandToLabelMap->getByName(sUIItemCommand);
 257         aGlobalVal >>= aGlobalPropSeq;
 258     }
 259     catch (container::NoSuchElementException&)
 260     {
 261     }
 262
 263     OUString aLabel;
 264     for (sal_Int32 i = 0; i < aPropSeq.getLength(); ++i)
 265         if (aPropSeq[i].Name == "Name")
 266             aPropSeq[i].Value >>= aLabel;
 267     if (aLabel.isEmpty())
 268         for (sal_Int32 i = 0; i < aGlobalPropSeq.getLength(); ++i)
 269             if (aGlobalPropSeq[i].Name == "Name")
 270                 aGlobalPropSeq[i].Value >>= aLabel;
 271
 272     OUString aName = SvxConfigPageHelper::stripHotKey(aLabel);
 273
 274     if (sClassId == "GtkSeparatorMenuItem" || sClassId == "GtkSeparator")
 275     {
 276         OUString sDataInTree = "--------------------------------------------";
 277         m_xContentsListBox->set_text(nPos, sDataInTree, nStartCol + 1);
 278     }
 279     else
 280     {
 281         if (aName.isEmpty())
 282             aName = sUIItemId;
 283         auto xImage = GetSaveInData()->GetImage(sUIItemCommand);
 284         if (xImage.is())
 285             m_xContentsListBox->set_image(nPos, xImage, nStartCol);
 286         m_xContentsListBox->set_text(nPos, aName, nStartCol + 1);
 287         m_xContentsListBox->set_id(nPos, sUIItemId);
 288     }
 289 }
 290
 291 void SvxNotebookbarConfigPage::getNodeValue(xmlNode* pNodePtr, NotebookbarEntries& aNodeEntries)
 292 {
 293     pNodePtr = pNodePtr->xmlChildrenNode;
 294     while (pNodePtr)
 295     {
 296         if (!(xmlStrcmp(pNodePtr->name, reinterpret_cast<const xmlChar*>("property"))))
 297         {
 298             xmlChar* UriValue = xmlGetProp(pNodePtr, reinterpret_cast<const xmlChar*>("name"));
 299             if (!(xmlStrcmp(UriValue, reinterpret_cast<const xmlChar*>("visible"))))
 300             {
 301                 xmlChar* aValue = xmlNodeGetContent(pNodePtr);
 302                 const char* cVisibleValue = reinterpret_cast<const char*>(aValue);
 303                 OUString sVisibleValue = charToString(cVisibleValue);
 304                 aNodeEntries.sVisibleValue = sVisibleValue;
 305                 xmlFree(aValue);
 306             }
 307             if (!(xmlStrcmp(UriValue, reinterpret_cast<const xmlChar*>("action_name"))))
 308             {
 309                 xmlChar* aValue = xmlNodeGetContent(pNodePtr);
 310                 const char* cActionName = reinterpret_cast<const char*>(aValue);
 311                 OUString sActionName = charToString(cActionName);
 312                 aNodeEntries.sActionName = sActionName;
 313                 xmlFree(aValue);
 314             }
 315             xmlFree(UriValue);
 316         }
 317         pNodePtr = pNodePtr->next;
 318     }
 319 }
 320
 321 void SvxNotebookbarConfigPage::searchNodeandAttribute(std::vector<NotebookbarEntries>& aEntries,
 322                                                       std::vector<CategoriesEntries>& aCategoryList,
 323                                                       OUString& sActiveCategory,
 324                                                       CategoriesEntries& aCurItemEntry,
 325                                                       xmlNode* pNodePtr, bool isCategory)
 326 {
 327     pNodePtr = pNodePtr->xmlChildrenNode;
 328     while (pNodePtr)
 329     {
 330         if (pNodePtr->type == XML_ELEMENT_NODE)
 331         {
 332             const char* cNodeName = reinterpret_cast<const char*>(pNodePtr->name);
 333             OUString sNodeName = charToString(cNodeName);
 334             OUString sSecondVal;
 335             if (sNodeName == "object")
 336             {
 337                 xmlChar* UriValue = xmlGetProp(pNodePtr, reinterpret_cast<const xmlChar*>("id"));
 338                 const char* cUIItemID = reinterpret_cast<const char*>(UriValue);
 339                 OUString sUIItemId = charToString(cUIItemID);
 340                 xmlFree(UriValue);
 341
 342                 UriValue = xmlGetProp(pNodePtr, reinterpret_cast<const xmlChar*>("class"));
 343                 const char* cClassId = reinterpret_cast<const char*>(UriValue);
 344                 OUString sClassId = charToString(cClassId);
 345                 xmlFree(UriValue);
 346
 347                 CategoriesEntries aCategoryEntry;
 348                 if (sClassId == "sfxlo-PriorityHBox")
 349                 {
 350                     aCategoryEntry.sDisplayName = sUIItemId;
 351                     aCategoryEntry.sUIItemId = sUIItemId;
 352                     aCategoryEntry.sClassType = sClassId;
 353                     aCategoryList.push_back(aCategoryEntry);
 354
 355                     aCurItemEntry = aCategoryEntry;
 356                 }
 357                 else if (sClassId == "sfxlo-PriorityMergedHBox")
 358                 {
 359                     aCategoryEntry.sDisplayName = aCurItemEntry.sDisplayName + " | " + sUIItemId;
 360                     aCategoryEntry.sUIItemId = sUIItemId;
 361                     aCategoryEntry.sClassType = sClassId;
 362
 363                     if (aCurItemEntry.sClassType == sClassId)
 364                     {
 365                         sal_Int32 rPos = 0;
 366                         aCategoryEntry.sDisplayName
 367                             = aCurItemEntry.sDisplayName.getToken(rPos, ' ', rPos) + " | "
 368                               + sUIItemId;
 369                     }
 370                     aCategoryList.push_back(aCategoryEntry);
 371                     aCurItemEntry = aCategoryEntry;
 372                 }
 373                 else if (sClassId == "svtlo-ManagedMenuButton")
 374                 {
 375                     sal_Int32 rPos = 1;
 376                     sSecondVal = sUIItemId.getToken(rPos, ':', rPos);
 377                     if (!sSecondVal.isEmpty())
 378                     {
 379                         aCategoryEntry.sDisplayName
 380                             = aCurItemEntry.sDisplayName + " | " + sSecondVal;
 381                         aCategoryEntry.sUIItemId = sSecondVal;
 382                         aCategoryList.push_back(aCategoryEntry);
 383                     }
 384                 }
 385
 386                 NotebookbarEntries nodeEntries;
 387                 if (isCategoryAvailable(sClassId, sUIItemId, sActiveCategory, isCategory)
 388                     || isCategory)
 389                 {
 390                     isCategory = true;
 391                     if (sClassId == "GtkMenuItem" || sClassId == "GtkToolButton"
 392                         || sClassId == "GtkMenuToolButton"
 393                         || (sClassId == "svtlo-ManagedMenuButton" && sSecondVal.isEmpty()))
 394                     {
 395                         nodeEntries.sClassId = sClassId;
 396                         nodeEntries.sUIItemId = sUIItemId;
 397                         nodeEntries.sDisplayName = sUIItemId;
 398
 399                         getNodeValue(pNodePtr, nodeEntries);
 400                         aEntries.push_back(nodeEntries);
 401                     }
 402                     else if (sClassId == "GtkSeparatorMenuItem" || sClassId == "GtkSeparator")
 403                     {
 404                         nodeEntries.sClassId = sClassId;
 405                         nodeEntries.sUIItemId = sUIItemId;
 406                         nodeEntries.sDisplayName = "Null";
 407                         nodeEntries.sVisibleValue = "Null";
 408                         nodeEntries.sActionName = "Null";
 409                         aEntries.push_back(nodeEntries);
 410                     }
 411                     else if (sClassId == "sfxlo-PriorityHBox"
 412                              || sClassId == "sfxlo-PriorityMergedHBox"
 413                              || sClassId == "svtlo-ManagedMenuButton")
 414                     {
 415                         nodeEntries.sClassId = sClassId;
 416                         nodeEntries.sUIItemId = sUIItemId;
 417                         nodeEntries.sDisplayName
 418                             = aCategoryList[aCategoryList.size() - 1].sDisplayName;
 419                         nodeEntries.sVisibleValue = "Null";
 420                         nodeEntries.sActionName = "Null";
 421                         aEntries.push_back(nodeEntries);
 422                     }
 423                 }
 424             }
 425             searchNodeandAttribute(aEntries, aCategoryList, sActiveCategory, aCurItemEntry,
 426                                    pNodePtr, isCategory);
 427         }
 428         pNodePtr = pNodePtr->next;
 429     }
 430 }
 431
 432 void SvxNotebookbarConfigPage::FillFunctionsList(std::vector<NotebookbarEntries>& aEntries,
 433                                                  std::vector<CategoriesEntries>& aCategoryList,
 434                                                  OUString& sActiveCategory)
 435 {
 436     xmlDocPtr pDoc;
 437     xmlNodePtr pNodePtr;
 438     OUString sUIFilePath = CustomNotebookbarGenerator::getCustomizedUIPath();
 439     char* cUIFileUIPath = CustomNotebookbarGenerator::convertToCharPointer(sUIFilePath);
 440     pDoc = xmlParseFile(cUIFileUIPath);
 441     pNodePtr = xmlDocGetRootElement(pDoc);
 442
 443     CategoriesEntries aCurItemEntry;
 444     searchNodeandAttribute(aEntries, aCategoryList, sActiveCategory, aCurItemEntry, pNodePtr,
 445                            false);
 446     if (pDoc != nullptr)
 447     {
 448         xmlFreeDoc(pDoc);
 449     }
 450     delete[] cUIFileUIPath;
 451 }
 452
 453 void SvxNotebookbarConfigPage::SelectElement()
 454 {
 455     m_xContentsListBox->clear();
 456     std::vector<NotebookbarEntries> aEntries;
 457     std::vector<CategoriesEntries> aCategoryList;
 458     OUString sActiveCategory = m_xTopLevelListBox->get_active_id();
 459     FillFunctionsList(aEntries, aCategoryList, sActiveCategory);
 460
 461     if (m_xTopLevelListBox->get_count() == 1)
 462     {
 463         for (std::size_t nIdx = 0; nIdx < aCategoryList.size(); nIdx++)
 464             m_xTopLevelListBox->append(aCategoryList[nIdx].sUIItemId,
 465                                        aCategoryList[nIdx].sDisplayName);
 466     }
 467     unsigned long nStart = 0;
 468     if (aEntries[nStart].sClassId == "sfxlo-PriorityHBox"
 469         || aEntries[nStart].sClassId == "sfxlo-PriorityMergedHBox")
 470         nStart = 1;
 471
 472     std::vector<NotebookbarEntries> aTempEntries;
 473     for (std::size_t nIdx = nStart; nIdx < aEntries.size(); nIdx++)
 474     {
 475         if (aEntries[nIdx].sClassId == "svtlo-ManagedMenuButton")
 476         {
 477             aTempEntries.push_back(aEntries[nIdx]);
 478             std::vector<NotebookbarEntries> aGtkEntries;
 479             sal_Int32 rPos = 1;
 480             sActiveCategory = aEntries[nIdx].sUIItemId.getToken(rPos, ':', rPos);
 481             FillFunctionsList(aGtkEntries, aCategoryList, sActiveCategory);
 482             for (std::size_t Idx = 0; Idx < aGtkEntries.size(); Idx++)
 483                 aTempEntries.push_back(aGtkEntries[Idx]);
 484             aGtkEntries.clear();
 485         }
 486         else
 487             aTempEntries.push_back(aEntries[nIdx]);
 488     }
 489
 490     aEntries = aTempEntries;
 491     aTempEntries.clear();
 492
 493     sal_Int64 nId = 0;
 494     for (std::size_t nIdx = 0; nIdx < aEntries.size(); nIdx++)
 495     {
 496         OUString sId(OUString::number(nId));
 497         m_xContentsListBox->insert(nIdx, sId);
 498         if (aEntries[nIdx].sActionName != "Null")
 499         {
 500             if (aEntries[nIdx].sVisibleValue == "True")
 501             {
 502                 m_xContentsListBox->set_toggle(nIdx, TRISTATE_TRUE, 0);
 503             }
 504             else
 505             {
 506                 m_xContentsListBox->set_toggle(nIdx, TRISTATE_FALSE, 0);
 507             }
 508         }
 509         InsertEntryIntoNotebookbarTabUI(aEntries[nIdx].sClassId, aEntries[nIdx].sDisplayName,
 510                                         aEntries[nIdx].sActionName, nIdx, 1);
 511         ++nId;
 512     }
 513     aEntries.clear();
 514 }
 515
 516 SvxNotebookbarEntriesListBox::SvxNotebookbarEntriesListBox(std::unique_ptr<weld::TreeView> xParent,
 517                                                            SvxConfigPage* pPg)
 518     : SvxMenuEntriesListBox(std::move(xParent), pPg)
 519 {
 520     m_xControl->connect_toggled(LINK(this, SvxNotebookbarEntriesListBox, CheckButtonHdl));
 521     m_xControl->connect_key_press(Link<const KeyEvent&, bool>());
 522     m_xControl->connect_key_press(LINK(this, SvxNotebookbarEntriesListBox, KeyInputHdl));
 523 }
 524
 525 SvxNotebookbarEntriesListBox::~SvxNotebookbarEntriesListBox() {}
 526
 527 static void EditRegistryFile(const OUString& sUIItemId, const OUString& sSetEntry,
 528                              const OUString& sNotebookbarInterface)
 529 {
 530     int nFlag = 0;
 531     Sequence<OUString> aOldEntries
 532         = CustomNotebookbarGenerator::getCustomizedUIItem(sNotebookbarInterface);
 533     Sequence<OUString> aNewEntries(aOldEntries.getLength() + 1);
 534     for (int nIdx = 0; nIdx < aOldEntries.getLength(); nIdx++)
 535     {
 536         sal_Int32 rPos = 0;
 537         OUString sFirstValue = aOldEntries[nIdx].getToken(rPos, ',', rPos);
 538         if (sFirstValue == sUIItemId)
 539         {
 540             aOldEntries[nIdx] = sSetEntry;
 541             nFlag = 1;
 542             break;
 543         }
 544         aNewEntries[nIdx] = aOldEntries[nIdx];
 545     }
 546
 547     if (nFlag == 0)
 548     {
 549         aNewEntries[aOldEntries.getLength()] = sSetEntry;
 550         CustomNotebookbarGenerator::setCustomizedUIItem(aNewEntries, sNotebookbarInterface);
 551     }
 552     else
 553     {
 554         CustomNotebookbarGenerator::setCustomizedUIItem(aOldEntries, sNotebookbarInterface);
 555     }
 556 }
 557
 558 void SvxNotebookbarEntriesListBox::ChangedVisibility(int nRow)
 559 {
 560     OUString sUIItemId = m_xControl->get_selected_id();
 561     OUString sAppName;
 562     OUString sFileName;
 563     CustomNotebookbarGenerator::getFileNameAndAppName(sAppName, sFileName);
 564     OUString sNotebookbarInterface = getFileName(sFileName);
 565
 566     OUString sVisible;
 567     if (m_xControl->get_toggle(nRow, 0) == TRISTATE_TRUE)
 568         sVisible = "True";
 569     else
 570         sVisible = "False";
 571     OUString sSetEntries = sUIItemId + ",visible," + sVisible;
 572     Sequence<OUString> sSeqOfEntries(1);
 573     sSeqOfEntries[0] = sSetEntries;
 574     EditRegistryFile(sUIItemId, sSetEntries, sNotebookbarInterface);
 575     CustomNotebookbarGenerator::modifyCustomizedUIFile(sSeqOfEntries);
 576     OUString sUIPath = "modules/s" + sAppName.toAsciiLowerCase() + "/ui/";
 577     sfx2::SfxNotebookBar::ReloadNotebookBar(sUIPath);
 578 }
 579
 580 IMPL_LINK(SvxNotebookbarEntriesListBox, CheckButtonHdl, const row_col&, rRowCol, void)
 581 {
 582     ChangedVisibility(rRowCol.first);
 583 }
 584
 585 IMPL_LINK(SvxNotebookbarEntriesListBox, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
 586 {
 587     if (rKeyEvent.GetKeyCode() == KEY_SPACE)
 588     {
 589         int nRow = m_xControl->get_selected_index();
 590         m_xControl->set_toggle(
 591             nRow, m_xControl->get_toggle(nRow, 0) == TRISTATE_TRUE ? TRISTATE_FALSE : TRISTATE_TRUE,
 592             0);
 593         ChangedVisibility(nRow);
 594         return true;
 595     }
 596     return SvxMenuEntriesListBox::KeyInputHdl(rKeyEvent);
 597 }
 598
 599 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */