include/vcl/uitest/uiobject.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_UITEST_UIOBJECT_HXX
  11 #define INCLUDED_VCL_UITEST_UIOBJECT_HXX
  12
  13 #include <rtl/ustring.hxx>
  14 #include <map>
  15 #include <memory>
  16
  17 #include <vcl/window.hxx>
  18 #include <vcl/spin.hxx>
  19 #include <vcl/button.hxx>
  20 #include <vcl/edit.hxx>
  21 #include <vcl/tabpage.hxx>
  22 #include <vcl/lstbox.hxx>
  23 #include <vcl/combobox.hxx>
  24 #include <vcl/spinfld.hxx>
  25 #include <vcl/tabctrl.hxx>
  26
  27 #include <vcl/dllapi.h>
  28
  29 #include <set>
  30
  31 typedef std::map<const OUString, OUString> StringMap;
  32
  33 /**
  34  * This class wraps a UI object like vcl::Window and provides
  35  * an interface for the UI testing.
  36  *
  37  * This class should only have virtual methods.
  38  */
  39 class UITEST_DLLPUBLIC UIObject
  40 {
  41     UIObject(UIObject &) = delete;
  42     void operator =(UIObject) = delete;
  43
  44 public:
  45     UIObject() = default;
  46
  47     virtual ~UIObject();
  48
  49     /**
  50      * Returns the state of the wrapped UI object as a
  51      * string key value map.
  52      */
  53     virtual StringMap get_state();
  54
  55     /**
  56      * Executes an action on the wrapped UI object,
  57      * possibly with some additional parameters
  58      */
  59     virtual void execute(const OUString& rAction,
  60             const StringMap& rParameters);
  61
  62     /**
  63      * Returns the type of the UIObject. Additional information might
  64      * be available through UIObject::get_state().
  65      */
  66     virtual OUString get_type() const;
  67
  68     /**
  69      * Returns the child of the current UIObject with the corresponding id.
  70      * If no object with that id is being found returns a nullptr.
  71      *
  72      */
  73     virtual std::unique_ptr<UIObject> get_child(const OUString& rID);
  74
  75     /**
  76      * Returns a set containing all descendants of the object.
  77      */
  78     virtual std::set<OUString> get_children() const;
  79
  80     /**
  81      * Currently an internal method to dump the state of the current UIObject as represented by get_state().
  82      *
  83      * This method should not be exposed to the outside world.
  84      *
  85      */
  86     virtual OUString dumpState() const;
  87
  88     /**
  89      * Currently an internal method to dump the parent-child relationship starting from the current top focus window.
  90      *
  91      * This method should not be exposed to the outside world.
  92      *
  93      */
  94     virtual OUString dumpHierarchy() const;
  95
  96     /**
  97      * Gets the corresponding Action string for the event.
  98      */
  99     virtual OUString get_action(VclEventId nEvent) const;
 100 };
 101
 102 class UITEST_DLLPUBLIC WindowUIObject : public UIObject
 103 {
 104     VclPtr<vcl::Window> mxWindow;
 105
 106 public:
 107
 108     WindowUIObject(VclPtr<vcl::Window> xWindow);
 109
 110     virtual StringMap get_state() override;
 111
 112     virtual void execute(const OUString& rAction,
 113             const StringMap& rParameters) override;
 114
 115     virtual OUString get_type() const override;
 116
 117     virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override;
 118
 119     virtual std::set<OUString> get_children() const override;
 120
 121     virtual OUString dumpState() const override;
 122
 123     virtual OUString dumpHierarchy() const override;
 124
 125     virtual OUString get_action(VclEventId nEvent) const override;
 126
 127     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 128
 129 protected:
 130
 131     virtual OUString get_name() const;
 132
 133 };
 134
 135 // TODO: moggi: what about push buttons?
 136 class UITEST_DLLPUBLIC ButtonUIObject : public WindowUIObject
 137 {
 138     VclPtr<Button> mxButton;
 139 public:
 140
 141     ButtonUIObject(VclPtr<Button> xButton);
 142     virtual ~ButtonUIObject() override;
 143
 144     virtual StringMap get_state() override;
 145
 146     virtual void execute(const OUString& rAction,
 147             const StringMap& rParameters) override;
 148
 149     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 150
 151 protected:
 152
 153     virtual OUString get_name() const override;
 154 };
 155
 156 class UITEST_DLLPUBLIC DialogUIObject : public WindowUIObject
 157 {
 158     VclPtr<Dialog> mxDialog;
 159
 160 public:
 161
 162     DialogUIObject(VclPtr<Dialog> xDialog);
 163     virtual ~DialogUIObject() override;
 164
 165     virtual StringMap get_state() override;
 166
 167     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 168
 169 protected:
 170
 171     virtual OUString get_name() const override;
 172 };
 173
 174 class UITEST_DLLPUBLIC EditUIObject : public WindowUIObject
 175 {
 176     VclPtr<Edit> mxEdit;
 177
 178 public:
 179
 180     EditUIObject(VclPtr<Edit> xEdit);
 181     virtual ~EditUIObject() override;
 182
 183     virtual void execute(const OUString& rAction,
 184             const StringMap& rParameters) override;
 185
 186     virtual StringMap get_state() override;
 187
 188     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 189
 190 protected:
 191
 192     virtual OUString get_name() const override;
 193 };
 194
 195 // TODO: moggi: maybe let it inherit from the button case
 196 class UITEST_DLLPUBLIC CheckBoxUIObject : public WindowUIObject
 197 {
 198 private:
 199     VclPtr<CheckBox> mxCheckBox;
 200
 201 public:
 202     CheckBoxUIObject(VclPtr<CheckBox> xCheckbox);
 203     virtual ~CheckBoxUIObject() override;
 204
 205     virtual void execute(const OUString& rAction,
 206             const StringMap& rParameters) override;
 207
 208     virtual StringMap get_state() override;
 209
 210     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 211
 212 protected:
 213
 214     virtual OUString get_name() const override;
 215 };
 216
 217 class UITEST_DLLPUBLIC RadioButtonUIObject : public WindowUIObject
 218 {
 219 private:
 220     VclPtr<RadioButton> mxRadioButton;
 221
 222 public:
 223     RadioButtonUIObject(VclPtr<RadioButton> xCheckbox);
 224     virtual ~RadioButtonUIObject() override;
 225
 226     virtual void execute(const OUString& rAction,
 227             const StringMap& rParameters) override;
 228
 229     virtual StringMap get_state() override;
 230
 231     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 232
 233 protected:
 234
 235     virtual OUString get_name() const override;
 236 };
 237
 238 class UITEST_DLLPUBLIC TabPageUIObject : public WindowUIObject
 239 {
 240 private:
 241     VclPtr<TabPage> mxTabPage;
 242 public:
 243     TabPageUIObject(VclPtr<TabPage> xTabPage);
 244     virtual ~TabPageUIObject() override;
 245
 246     virtual void execute(const OUString& rAction,
 247             const StringMap& rParameters) override;
 248
 249     virtual StringMap get_state() override;
 250
 251     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 252
 253 protected:
 254
 255     virtual OUString get_name() const override;
 256 };
 257
 258 class UITEST_DLLPUBLIC ListBoxUIObject : public WindowUIObject
 259 {
 260 private:
 261     VclPtr<ListBox> mxListBox;
 262
 263 public:
 264
 265     ListBoxUIObject(VclPtr<ListBox> xListBox);
 266     virtual ~ListBoxUIObject() override;
 267
 268     virtual void execute(const OUString& rAction,
 269             const StringMap& rParameters) override;
 270
 271     virtual StringMap get_state() override;
 272
 273     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 274
 275     virtual OUString get_action(VclEventId nEvent) const override;
 276
 277 protected:
 278
 279     virtual OUString get_name() const override;
 280 };
 281
 282 // TODO: moggi: should it inherit from EditUIObject?
 283 class UITEST_DLLPUBLIC ComboBoxUIObject : public WindowUIObject
 284 {
 285 private:
 286     VclPtr<ComboBox> mxComboBox;
 287
 288 public:
 289
 290     ComboBoxUIObject(VclPtr<ComboBox> xListBox);
 291     virtual ~ComboBoxUIObject() override;
 292
 293     virtual void execute(const OUString& rAction,
 294             const StringMap& rParameters) override;
 295
 296     virtual StringMap get_state() override;
 297
 298     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 299
 300 protected:
 301
 302     virtual OUString get_name() const override;
 303 };
 304
 305 class UITEST_DLLPUBLIC SpinUIObject : public WindowUIObject
 306 {
 307 private:
 308     VclPtr<SpinButton> mxSpinButton;
 309
 310 public:
 311
 312     SpinUIObject(VclPtr<SpinButton> xSpinButton);
 313     virtual ~SpinUIObject() override;
 314
 315     virtual void execute(const OUString& rAction,
 316             const StringMap& rParameters) override;
 317
 318     virtual StringMap get_state() override;
 319
 320     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 321
 322 protected:
 323
 324     virtual OUString get_name() const override;
 325 };
 326
 327 class UITEST_DLLPUBLIC SpinFieldUIObject : public EditUIObject
 328 {
 329     VclPtr<SpinField> mxSpinField;
 330
 331 public:
 332
 333     SpinFieldUIObject(VclPtr<SpinField> xEdit);
 334     virtual ~SpinFieldUIObject() override;
 335
 336     virtual void execute(const OUString& rAction,
 337             const StringMap& rParameters) override;
 338
 339     virtual StringMap get_state() override;
 340
 341     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 342
 343 protected:
 344
 345     virtual OUString get_name() const override;
 346 };
 347
 348 class UITEST_DLLPUBLIC TabControlUIObject : public WindowUIObject
 349 {
 350 private:
 351     VclPtr<TabControl> mxTabControl;
 352
 353 public:
 354
 355     TabControlUIObject(VclPtr<TabControl> mxTabControl);
 356     virtual ~TabControlUIObject() override;
 357
 358     virtual void execute(const OUString& rAction,
 359             const StringMap& rParameters) override;
 360
 361     virtual StringMap get_state() override;
 362
 363     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 364
 365 protected:
 366
 367     virtual OUString get_name() const override;
 368 };
 369
 370 #endif
 371
 372 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */