include/vcl/builder.hxx

   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
  10 #ifndef INCLUDED_VCL_BUILDER_HXX
  11 #define INCLUDED_VCL_BUILDER_HXX
  12
  13 #include <typeinfo>
  14 #include <osl/module.hxx>
  15 #include <sal/log.hxx>
  16 #include <tools/resmgr.hxx>
  17 #include <tools/fldunit.hxx>
  18 #include <vcl/dllapi.h>
  19 #include <vcl/window.hxx>
  20 #include <vcl/vclptr.hxx>
  21 #include <tools/wintypes.hxx>
  22 #include <vcl/EnumContext.hxx>
  23
  24 #include <memory>
  25 #include <map>
  26 #include <set>
  27 #include <stack>
  28 #include <vector>
  29 #ifdef check
  30 #  //some problem with MacOSX and a check define
  31 #  undef check
  32 #endif
  33
  34 #include <com/sun/star/frame/XFrame.hpp>
  35 #include <com/sun/star/uno/XComponentContext.hpp>
  36
  37 class ListBox;
  38 class NumericFormatter;
  39 class PopupMenu;
  40 class ScrollBar;
  41 class Slider;
  42 class DateField;
  43 class TimeField;
  44 class VclExpander;
  45 class VclMultiLineEdit;
  46 namespace xmlreader { class XmlReader; }
  47
  48 class VCL_DLLPUBLIC VclBuilder
  49 {
  50 public:
  51     typedef std::map<OString, OUString> stringmap;
  52     typedef std::map<OString, std::pair<OString, OString>> accelmap;
  53     /// These functions create a new widget with parent pParent and return it in rRet
  54     typedef void (*customMakeWidget)(VclPtr<vcl::Window> &rRet, VclPtr<vcl::Window> &pParent, stringmap &rVec);
  55
  56 public:
  57     VclBuilder(
  58             vcl::Window *pParent,
  59             const OUString& sUIRootDir,
  60             const OUString& sUIFile,
  61             const OString& sID = OString(),
  62             const css::uno::Reference<css::frame::XFrame> &rFrame = css::uno::Reference<css::frame::XFrame>());
  63     ~VclBuilder();
  64
  65     ///releases references and disposes all children.
  66     void disposeBuilder();
  67
  68     //sID must exist and be of type T
  69     template <typename T> T* get(VclPtr<T>& ret, const OString& sID);
  70
  71     //sID may not exist, but must be of type T if it does
  72     template <typename T /*= vcl::Window if we had c++11*/> T* get(const OString& sID);
  73
  74     vcl::Window*    get_widget_root();
  75
  76     //sID may not exist
  77     PopupMenu*      get_menu(const OString& sID);
  78
  79     //given an sID return the response value for that widget
  80     short           get_response(const vcl::Window *pWindow) const;
  81
  82     OString         get_by_window(const vcl::Window *pWindow) const;
  83     void            delete_by_window(vcl::Window *pWindow);
  84
  85     //release ownership of pWindow, i.e. don't delete it
  86     void            drop_ownership(const vcl::Window *pWindow);
  87
  88     //apply the properties of rProps to pWindow
  89     static void     set_properties(vcl::Window *pWindow, const stringmap &rProps);
  90
  91     //Convert _ gtk markup to ~ vcl markup
  92     static          OUString convertMnemonicMarkup(const OUString &rIn);
  93
  94     static OUString extractCustomProperty(stringmap &rMap);
  95     static FieldUnit detectUnit(OUString const&);
  96
  97     static bool     extractDropdown(stringmap &rMap);
  98
  99     //add a default value of 25 width-chars to a map if width-chars not set
 100     static void     ensureDefaultWidthChars(VclBuilder::stringmap &rMap);
 101
 102     //see m_aDeferredProperties, you need this for toplevel dialogs
 103     //which build themselves from their ctor. The properties on
 104     //the top level are stored in m_aDeferredProperties and need
 105     //to be applied post ctor
 106     void            setDeferredProperties();
 107
 108     //Helpers to retrofit all the existing code to the builder
 109     static void     reorderWithinParent(std::vector< vcl::Window*>& rChilds, bool bIsButtonBox);
 110     static void     reorderWithinParent(vcl::Window &rWindow, sal_uInt16 nNewPosition);
 111
 112     /// return UI-File name (without '.ui')
 113     const OString& getUIFile() const
 114     {
 115         return m_sHelpRoot;
 116     }
 117
 118 private:
 119     VclBuilder(const VclBuilder&) = delete;
 120     VclBuilder& operator=(const VclBuilder&) = delete;
 121
 122     typedef std::map<OUString, std::unique_ptr<osl::Module>> ModuleMap;
 123
 124     //We store these until the builder is deleted, that way we can use the
 125     //ui-previewer on custom widgets and guarantee the modules they are from
 126     //exist for the duration of the dialog
 127     ModuleMap       m_aModuleMap;
 128
 129     //If the toplevel window has any properties which need to be set on it,
 130     //but the toplevel is the owner of the builder, then its ctor
 131     //has not been completed during the building, so properties for it
 132     //are collected here and need to be set afterwards, e.g. during
 133     //Show or Execute
 134     stringmap      m_aDeferredProperties;
 135
 136     struct PackingData
 137     {
 138         bool m_bVerticalOrient;
 139         sal_Int32 m_nPosition;
 140         PackingData(bool bVerticalOrient = false)
 141             : m_bVerticalOrient(bVerticalOrient)
 142             , m_nPosition(-1)
 143         {
 144         }
 145     };
 146
 147     struct WinAndId
 148     {
 149         OString m_sID;
 150         VclPtr<vcl::Window> m_pWindow;
 151         short m_nResponseId;
 152         PackingData m_aPackingData;
 153         WinAndId(const OString &rId, vcl::Window *pWindow, bool bVertical)
 154             : m_sID(rId)
 155             , m_pWindow(pWindow)
 156             , m_nResponseId(RET_CANCEL)
 157             , m_aPackingData(bVertical)
 158         {
 159         }
 160     };
 161     std::vector<WinAndId> m_aChildren;
 162
 163     struct MenuAndId
 164     {
 165         OString m_sID;
 166         VclPtr<PopupMenu> m_pMenu;
 167         MenuAndId(const OString &rId, PopupMenu *pMenu);
 168         ~MenuAndId();
 169     };
 170     std::vector<MenuAndId> m_aMenus;
 171
 172     struct StringPair
 173     {
 174         OString m_sID;
 175         OString m_sValue;
 176         StringPair(const OString &rId, const OString &rValue)
 177             : m_sID(rId)
 178             , m_sValue(rValue)
 179         {
 180         }
 181     };
 182
 183     struct UStringPair
 184     {
 185         OString m_sID;
 186         OUString m_sValue;
 187         UStringPair(const OString &rId, const OUString &rValue)
 188             : m_sID(rId)
 189             , m_sValue(rValue)
 190         {
 191         }
 192     };
 193
 194     typedef StringPair RadioButtonGroupMap;
 195
 196     struct ButtonImageWidgetMap
 197     {
 198         OString m_sID;
 199         OUString m_sValue;
 200         bool m_bRadio;
 201         ButtonImageWidgetMap(const OString &rId, const OUString &rValue, bool bRadio)
 202             : m_sID(rId)
 203             , m_sValue(rValue)
 204             , m_bRadio(bRadio)
 205         {
 206         }
 207     };
 208
 209     typedef UStringPair TextBufferMap;
 210     typedef UStringPair WidgetAdjustmentMap;
 211     typedef UStringPair ButtonMenuMap;
 212     typedef UStringPair MnemonicWidgetMap;
 213
 214     struct ComboBoxModelMap
 215     {
 216         OString m_sID;
 217         OUString m_sValue;
 218         sal_Int32 m_nActiveId;
 219         ComboBoxModelMap(const OString &rId, const OUString &rValue, sal_Int32 nActiveId)
 220             : m_sID(rId)
 221             , m_sValue(rValue)
 222             , m_nActiveId(nActiveId)
 223         {
 224         }
 225     };
 226
 227     struct ListStore
 228     {
 229         typedef std::vector<OUString> row;
 230         std::vector<row> m_aEntries;
 231     };
 232
 233     const ListStore* get_model_by_name(const OString& sID) const;
 234     static void     mungeModel(ListBox &rTarget, const ListStore &rStore, sal_uInt16 nActiveId);
 235
 236     typedef stringmap TextBuffer;
 237     const TextBuffer* get_buffer_by_name(const OString& sID) const;
 238
 239     static void     mungeTextBuffer(VclMultiLineEdit &rTarget, const TextBuffer &rTextBuffer);
 240
 241     typedef stringmap Adjustment;
 242     const Adjustment* get_adjustment_by_name(const OString& sID) const;
 243
 244     static void     mungeAdjustment(NumericFormatter &rTarget, const Adjustment &rAdjustment);
 245     static void     mungeAdjustment(DateField &rTarget, const Adjustment &rAdjustment);
 246     static void     mungeAdjustment(TimeField &rTarget, const Adjustment &rAdjustment);
 247     static void     mungeAdjustment(ScrollBar &rTarget, const Adjustment &rAdjustment);
 248     static void     mungeAdjustment(Slider &rTarget, const Adjustment &rAdjustment);
 249
 250     typedef std::map<OString, OString> WidgetTranslations;
 251     typedef std::map<OString, WidgetTranslations> Translations;
 252
 253     struct stockinfo
 254     {
 255         OUString m_sStock;
 256         int m_nSize;
 257         stockinfo() : m_nSize(4) {}
 258     };
 259
 260     typedef std::map<OString, stockinfo> StockMap;
 261
 262     struct SizeGroup
 263     {
 264         std::vector<OString> m_aWidgets;
 265         stringmap m_aProperties;
 266         SizeGroup() {}
 267     };
 268
 269     typedef std::map<VclPtr<vcl::Window>, stringmap> AtkMap;
 270
 271     struct ParserState
 272     {
 273         std::vector<RadioButtonGroupMap> m_aGroupMaps;
 274
 275         std::vector<ComboBoxModelMap> m_aModelMaps;
 276         std::map<OString, ListStore> m_aModels;
 277
 278         std::vector<TextBufferMap> m_aTextBufferMaps;
 279         std::map<OString, TextBuffer> m_aTextBuffers;
 280
 281         std::vector<WidgetAdjustmentMap> m_aNumericFormatterAdjustmentMaps;
 282         std::vector<WidgetAdjustmentMap> m_aTimeFormatterAdjustmentMaps;
 283         std::vector<WidgetAdjustmentMap> m_aDateFormatterAdjustmentMaps;
 284         std::vector<WidgetAdjustmentMap> m_aScrollAdjustmentMaps;
 285         std::vector<WidgetAdjustmentMap> m_aSliderAdjustmentMaps;
 286
 287         std::map<OString, Adjustment> m_aAdjustments;
 288
 289         std::vector<ButtonImageWidgetMap> m_aButtonImageWidgetMaps;
 290         StockMap m_aStockMap;
 291
 292         std::vector<ButtonMenuMap> m_aButtonMenuMaps;
 293
 294         Translations m_aTranslations;
 295
 296         std::map<VclPtr<vcl::Window>, VclPtr<vcl::Window>> m_aRedundantParentWidgets;
 297
 298         std::vector<SizeGroup> m_aSizeGroups;
 299
 300         AtkMap m_aAtkInfo;
 301
 302         std::vector<MnemonicWidgetMap> m_aMnemonicWidgetMaps;
 303
 304         std::vector< VclPtr<VclExpander> > m_aExpanderWidgets;
 305
 306         sal_uInt16 m_nLastToolbarId;
 307
 308         sal_uInt16 m_nLastMenuItemId;
 309
 310         ParserState();
 311     };
 312
 313     void        loadTranslations(const LanguageTag &rLanguageTag, const OUString &rUri);
 314     OString     getTranslation(const OString &rId, const OString &rProperty) const;
 315
 316     OString     m_sID;
 317     OString     m_sHelpRoot;
 318     ResHookProc m_pStringReplace;
 319     VclPtr<vcl::Window> m_pParent;
 320     bool        m_bToplevelHasDeferredInit;
 321     bool        m_bToplevelHasDeferredProperties;
 322     bool        m_bToplevelParentFound;
 323     std::unique_ptr<ParserState> m_pParserState;
 324
 325     vcl::Window *get_by_name(const OString& sID);
 326     void        delete_by_name(const OString& sID);
 327
 328     class sortIntoBestTabTraversalOrder
 329         : public std::binary_function<const vcl::Window*, const vcl::Window*, bool>
 330     {
 331     public:
 332                 sortIntoBestTabTraversalOrder(VclBuilder *pBuilder)
 333                     : m_pBuilder(pBuilder) {}
 334
 335         bool    operator()(const vcl::Window *pA, const vcl::Window *pB) const;
 336
 337     private:
 338         VclBuilder *m_pBuilder;
 339     };
 340
 341     /// XFrame to be able to extract labels and other properties of the UNO commands (like of .uno:Bold).
 342     css::uno::Reference<css::frame::XFrame> m_xFrame;
 343
 344 private:
 345     VclPtr<vcl::Window> insertObject(vcl::Window *pParent,
 346                     const OString &rClass, const OString &rID,
 347                     stringmap &rProps, stringmap &rPangoAttributes,
 348                     stringmap &rAtkProps);
 349
 350     VclPtr<vcl::Window> makeObject(vcl::Window *pParent,
 351                     const OString &rClass, const OString &rID,
 352                     stringmap &rVec);
 353
 354     void        connectNumericFormatterAdjustment(const OString &id, const OUString &rAdjustment);
 355     void        connectTimeFormatterAdjustment(const OString &id, const OUString &rAdjustment);
 356     void        connectDateFormatterAdjustment(const OString &id, const OUString &rAdjustment);
 357
 358     bool        extractGroup(const OString &id, stringmap &rVec);
 359     bool        extractModel(const OString &id, stringmap &rVec);
 360     bool        extractBuffer(const OString &id, stringmap &rVec);
 361     static bool extractAdjustmentToMap(const OString &id, stringmap &rVec, std::vector<WidgetAdjustmentMap>& rAdjustmentMap);
 362     bool        extractButtonImage(const OString &id, stringmap &rMap, bool bRadio);
 363     bool        extractStock(const OString &id, stringmap &rMap);
 364     void        extractMnemonicWidget(const OString &id, stringmap &rMap);
 365
 366     void        handleTranslations(xmlreader::XmlReader &reader);
 367
 368     void        handleChild(vcl::Window *pParent, xmlreader::XmlReader &reader);
 369     VclPtr<vcl::Window> handleObject(vcl::Window *pParent, xmlreader::XmlReader &reader);
 370     void        handlePacking(vcl::Window *pCurrent, vcl::Window *pParent, xmlreader::XmlReader &reader);
 371     static std::vector<vcl::EnumContext::Context> handleStyle(xmlreader::XmlReader &reader, int &nPriority);
 372     static OString getStyleClass(xmlreader::XmlReader &reader);
 373     void        applyPackingProperty(vcl::Window *pCurrent, vcl::Window *pParent, xmlreader::XmlReader &reader);
 374     void        collectProperty(xmlreader::XmlReader &reader, const OString &rID, stringmap &rVec);
 375     static void collectPangoAttribute(xmlreader::XmlReader &reader, stringmap &rMap);
 376     static void collectAtkAttribute(xmlreader::XmlReader &reader, stringmap &rMap);
 377     static void collectAccelerator(xmlreader::XmlReader &reader, accelmap &rMap);
 378
 379     void        insertMenuObject(
 380                    PopupMenu *pParent,
 381                    PopupMenu *pSubMenu,
 382                    const OString &rClass,
 383                    const OString &rID,
 384                    stringmap &rProps,
 385                    accelmap &rAccels);
 386
 387     void        handleMenuChild(PopupMenu *pParent, xmlreader::XmlReader &reader);
 388     void        handleMenuObject(PopupMenu *pParent, xmlreader::XmlReader &reader);
 389
 390     void        handleListStore(xmlreader::XmlReader &reader, const OString &rID);
 391     void        handleRow(xmlreader::XmlReader &reader, const OString &rID, sal_Int32 nRowIndex);
 392     void        handleTabChild(vcl::Window *pParent, xmlreader::XmlReader &reader);
 393     void        handleMenu(xmlreader::XmlReader &reader, const OString &rID);
 394     std::vector<OUString> handleItems(xmlreader::XmlReader &reader, const OString &rID);
 395
 396     void        handleSizeGroup(xmlreader::XmlReader &reader, const OString &rID);
 397
 398     void        handleAtkObject(xmlreader::XmlReader &reader, const OString &rID, vcl::Window *pWindow);
 399
 400     void        handleActionWidget(xmlreader::XmlReader &reader);
 401
 402     PackingData get_window_packing_data(const vcl::Window *pWindow) const;
 403     void        set_window_packing_position(const vcl::Window *pWindow, sal_Int32 nPosition);
 404
 405     static vcl::Window* prepareWidgetOwnScrolling(vcl::Window *pParent, WinBits &rWinStyle);
 406     void        cleanupWidgetOwnScrolling(vcl::Window *pScrollParent, vcl::Window *pWindow, stringmap &rMap);
 407
 408     void        set_response(const OString& sID, short nResponse);
 409 };
 410
 411 template <typename T>
 412 inline T* VclBuilder::get(VclPtr<T>& ret, const OString& sID)
 413 {
 414     vcl::Window *w = get_by_name(sID);
 415     SAL_WARN_IF(!w, "vcl.layout", "widget \"" << sID.getStr() << "\" not found in .ui");
 416     SAL_WARN_IF(!dynamic_cast<T*>(w),
 417        "vcl.layout", ".ui widget \"" << sID.getStr() << "\" needs to correspond to vcl type " << typeid(T).name());
 418     assert(w);
 419     assert(dynamic_cast<T*>(w));
 420     ret = static_cast<T*>(w);
 421     return ret.get();
 422 }
 423
 424 //sID may not exist, but must be of type T if it does
 425 template <typename T /*= vcl::Window if we had c++11*/>
 426 inline T* VclBuilder::get(const OString& sID)
 427 {
 428     vcl::Window *w = get_by_name(sID);
 429     SAL_WARN_IF(w && !dynamic_cast<T*>(w),
 430         "vcl.layout", ".ui widget \"" << sID.getStr() << "\" needs to correspond to vcl type " << typeid(T).name());
 431     assert(!w || dynamic_cast<T*>(w));
 432     return static_cast<T*>(w);
 433 }
 434
 435
 436 //helper baseclass to ease retro fitting dialogs/tabpages that load a resource
 437 //to load a .ui file instead
 438 //
 439 //vcl requires the Window Children of a Parent Window to be destroyed before
 440 //the Parent Window.  VclBuilderContainer owns the VclBuilder which owns the
 441 //Children Window. So the VclBuilderContainer dtor must be called before
 442 //the Parent Window dtor.
 443 //
 444 //i.e.  class Dialog : public SystemWindow, public VclBuilderContainer
 445 //not   class Dialog : public VclBuilderContainer, public SystemWindow
 446 //
 447 //With the new 'dispose' framework, it is necessary to force the builder
 448 //dispose before the Window dispose; so a Dialog::dispose() method would
 449 //finish: disposeBuilder(); SystemWindow::dispose() to capture this ordering.
 450
 451 class VCL_DLLPUBLIC VclBuilderContainer
 452 {
 453 public:
 454                     VclBuilderContainer();
 455     virtual         ~VclBuilderContainer();
 456     void            disposeBuilder();
 457
 458     static OUString getUIRootDir();
 459     bool            hasBuilder() const { return m_pUIBuilder != nullptr; }
 460
 461     template <typename T> T* get(VclPtr<T>& ret, const OString& sID)
 462     {
 463         return m_pUIBuilder->get<T>(ret, sID);
 464     }
 465     template <typename T /*= vcl::Window if we had c++11*/> T* get(const OString & sID)
 466     {
 467         return m_pUIBuilder->get<T>(sID);
 468     }
 469     PopupMenu* get_menu(const OString & sID)
 470     {
 471         return m_pUIBuilder->get_menu(sID);
 472     }
 473     void setDeferredProperties()
 474     {
 475         if (!m_pUIBuilder)
 476             return;
 477         m_pUIBuilder->setDeferredProperties();
 478     }
 479     OString getUIFile() const
 480     {
 481         if (m_pUIBuilder)
 482         {
 483             return m_pUIBuilder->getUIFile();
 484         }
 485
 486         return OString();
 487     }
 488
 489 protected:
 490     std::unique_ptr<VclBuilder> m_pUIBuilder;
 491 };
 492
 493 /*
 494  * @return true if rValue is "True", "true", "1", etc.
 495  */
 496 bool VCL_DLLPUBLIC toBool(const OUString &rValue);
 497
 498 #endif
 499
 500 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */