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/vclevent.hxx>
  18 #include <vcl/vclptr.hxx>
  19 #include <vcl/dllapi.h>
  20 #include <vcl/window.hxx>
  21
  22 #include <set>
  23
  24 class Button;
  25 class CheckBox;
  26 class ComboBox;
  27 class Dialog;
  28 class Edit;
  29 class IconView;
  30 class ListBox;
  31 class RadioButton;
  32 class TabControl;
  33 class TabPage;
  34 class SvTreeListBox;
  35 class SvTreeListEntry;
  36 class SpinButton;
  37 class SpinField;
  38 class VerticalTabControl;
  39 class VclExpander;
  40 class VclDrawingArea;
  41 class VclMultiLineEdit;
  42 class MenuButton;
  43 class ToolBox;
  44 namespace vcl { class Window; }
  45 namespace weld { class CustomWidgetController; }
  46
  47 typedef std::map<OUString, OUString> StringMap;
  48
  49 /**
  50  * This class wraps a UI object like vcl::Window and provides
  51  * an interface for the UI testing.
  52  *
  53  * This class should only have virtual methods.
  54  */
  55 class UITEST_DLLPUBLIC UIObject
  56 {
  57     UIObject(UIObject const &) = delete;
  58     UIObject& operator =(UIObject const &) = delete;
  59
  60 public:
  61     UIObject() = default;
  62
  63     virtual ~UIObject();
  64
  65     /**
  66      * Returns the state of the wrapped UI object as a
  67      * string key value map.
  68      */
  69     virtual StringMap get_state();
  70
  71     /**
  72      * Executes an action on the wrapped UI object,
  73      * possibly with some additional parameters
  74      */
  75     virtual void execute(const OUString& rAction,
  76             const StringMap& rParameters);
  77
  78     /**
  79      * Returns the type of the UIObject. Additional information might
  80      * be available through UIObject::get_state().
  81      */
  82     virtual OUString get_type() const;
  83
  84     /**
  85      * Returns the child of the current UIObject with the corresponding id.
  86      * If no object with that id is being found returns a nullptr.
  87      *
  88      */
  89     virtual std::unique_ptr<UIObject> get_child(const OUString& rID);
  90
  91     /**
  92      * Returns a set containing all descendants of the object.
  93      */
  94     virtual std::set<OUString> get_children() const;
  95
  96     /**
  97      * Currently an internal method to dump the state of the current UIObject as represented by get_state().
  98      *
  99      * This method should not be exposed to the outside world.
 100      *
 101      */
 102     virtual OUString dumpState() const;
 103
 104     /**
 105      * Currently an internal method to dump the parent-child relationship starting from the current top focus window.
 106      *
 107      * This method should not be exposed to the outside world.
 108      *
 109      */
 110     virtual OUString dumpHierarchy() const;
 111
 112     /**
 113      * Gets the corresponding Action string for the event.
 114      */
 115     virtual OUString get_action(VclEventId nEvent) const;
 116 };
 117
 118 class UITEST_DLLPUBLIC WindowUIObject : public UIObject
 119 {
 120     VclPtr<vcl::Window> mxWindow;
 121
 122 public:
 123
 124     WindowUIObject(const VclPtr<vcl::Window>& xWindow);
 125
 126     virtual StringMap get_state() override;
 127
 128     virtual void execute(const OUString& rAction,
 129             const StringMap& rParameters) override;
 130
 131     virtual OUString get_type() const override;
 132
 133     virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override;
 134
 135     std::unique_ptr<UIObject> get_visible_child(const OUString& rID);
 136
 137     virtual std::set<OUString> get_children() const override;
 138
 139     virtual OUString dumpState() const override;
 140
 141     virtual OUString dumpHierarchy() const override;
 142
 143     virtual OUString get_action(VclEventId nEvent) const override;
 144
 145     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 146
 147 protected:
 148
 149     virtual OUString get_name() const;
 150
 151 };
 152
 153 // TODO: moggi: what about push buttons?
 154 class ButtonUIObject final : public WindowUIObject
 155 {
 156     VclPtr<Button> mxButton;
 157 public:
 158
 159     ButtonUIObject(const VclPtr<Button>& xButton);
 160     virtual ~ButtonUIObject() override;
 161
 162     virtual StringMap get_state() override;
 163
 164     virtual void execute(const OUString& rAction,
 165             const StringMap& rParameters) override;
 166
 167     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 168
 169     virtual OUString get_action(VclEventId nEvent) const override;
 170
 171 private:
 172
 173     virtual OUString get_name() const override;
 174 };
 175
 176 class DialogUIObject final : public WindowUIObject
 177 {
 178     VclPtr<Dialog> mxDialog;
 179
 180 public:
 181
 182     DialogUIObject(const VclPtr<Dialog>& xDialog);
 183     virtual ~DialogUIObject() override;
 184
 185     virtual StringMap get_state() override;
 186
 187     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 188
 189 private:
 190
 191     virtual OUString get_name() const override;
 192 };
 193
 194 class EditUIObject : public WindowUIObject
 195 {
 196     VclPtr<Edit> mxEdit;
 197
 198 public:
 199
 200     EditUIObject(const VclPtr<Edit>& xEdit);
 201     virtual ~EditUIObject() override;
 202
 203     virtual void execute(const OUString& rAction,
 204             const StringMap& rParameters) override;
 205
 206     virtual StringMap get_state() override;
 207
 208     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 209
 210     virtual OUString get_action(VclEventId nEvent) const override;
 211
 212 protected:
 213
 214     virtual OUString get_name() const override;
 215 };
 216
 217 class MultiLineEditUIObject final : public WindowUIObject
 218 {
 219     VclPtr<VclMultiLineEdit> mxEdit;
 220
 221 public:
 222
 223     MultiLineEditUIObject(const VclPtr<VclMultiLineEdit>& xEdit);
 224     virtual ~MultiLineEditUIObject() 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 private:
 234
 235     virtual OUString get_name() const override;
 236 };
 237
 238 class ExpanderUIObject final : public WindowUIObject
 239 {
 240     VclPtr<VclExpander> mxExpander;
 241
 242 public:
 243
 244     ExpanderUIObject(const VclPtr<VclExpander>& xExpander);
 245     virtual ~ExpanderUIObject() override;
 246
 247     virtual void execute(const OUString& rAction,
 248             const StringMap& rParameters) override;
 249
 250     virtual StringMap get_state() override;
 251
 252     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 253 private:
 254
 255     virtual OUString get_name() const override;
 256 };
 257
 258
 259 // TODO: moggi: maybe let it inherit from the button case
 260 class CheckBoxUIObject final : public WindowUIObject
 261 {
 262 private:
 263     VclPtr<CheckBox> mxCheckBox;
 264
 265 public:
 266     CheckBoxUIObject(const VclPtr<CheckBox>& xCheckbox);
 267     virtual ~CheckBoxUIObject() override;
 268
 269     virtual void execute(const OUString& rAction,
 270             const StringMap& rParameters) override;
 271
 272     virtual StringMap get_state() override;
 273
 274     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 275
 276     virtual OUString get_action(VclEventId nEvent) const override;
 277
 278 private:
 279
 280     virtual OUString get_name() const override;
 281 };
 282
 283 class RadioButtonUIObject final : public WindowUIObject
 284 {
 285 private:
 286     VclPtr<RadioButton> mxRadioButton;
 287
 288 public:
 289     RadioButtonUIObject(const VclPtr<RadioButton>& xCheckbox);
 290     virtual ~RadioButtonUIObject() override;
 291
 292     virtual void execute(const OUString& rAction,
 293             const StringMap& rParameters) override;
 294
 295     virtual StringMap get_state() override;
 296
 297     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 298
 299     virtual OUString get_action(VclEventId nEvent) const override;
 300
 301 private:
 302
 303     virtual OUString get_name() const override;
 304 };
 305
 306 class TabPageUIObject final : public WindowUIObject
 307 {
 308 private:
 309     VclPtr<TabPage> mxTabPage;
 310 public:
 311     TabPageUIObject(const VclPtr<TabPage>& xTabPage);
 312     virtual ~TabPageUIObject() override;
 313
 314     virtual void execute(const OUString& rAction,
 315             const StringMap& rParameters) override;
 316
 317     virtual StringMap get_state() override;
 318
 319     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 320
 321 private:
 322
 323     virtual OUString get_name() const override;
 324 };
 325
 326 class ListBoxUIObject final : public WindowUIObject
 327 {
 328 private:
 329     VclPtr<ListBox> mxListBox;
 330
 331 public:
 332
 333     ListBoxUIObject(const VclPtr<ListBox>& xListBox);
 334     virtual ~ListBoxUIObject() 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     virtual OUString get_action(VclEventId nEvent) const override;
 344
 345 private:
 346
 347     virtual OUString get_name() const override;
 348 };
 349
 350 // TODO: moggi: should it inherit from EditUIObject?
 351 class ComboBoxUIObject final : public WindowUIObject
 352 {
 353 private:
 354     VclPtr<ComboBox> mxComboBox;
 355
 356 public:
 357
 358     ComboBoxUIObject(const VclPtr<ComboBox>& xListBox);
 359     virtual ~ComboBoxUIObject() override;
 360
 361     virtual void execute(const OUString& rAction,
 362             const StringMap& rParameters) override;
 363
 364     virtual StringMap get_state() override;
 365
 366     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 367
 368     virtual OUString get_action(VclEventId nEvent) const override;
 369
 370 private:
 371
 372     virtual OUString get_name() const override;
 373 };
 374
 375 class SpinUIObject final : public WindowUIObject
 376 {
 377 private:
 378     VclPtr<SpinButton> mxSpinButton;
 379
 380 public:
 381
 382     SpinUIObject(const VclPtr<SpinButton>& xSpinButton);
 383     virtual ~SpinUIObject() override;
 384
 385     virtual void execute(const OUString& rAction,
 386             const StringMap& rParameters) override;
 387
 388     virtual StringMap get_state() override;
 389
 390     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 391
 392     virtual OUString get_action(VclEventId nEvent) const override;
 393
 394 private:
 395
 396     virtual OUString get_name() const override;
 397 };
 398
 399 class SpinFieldUIObject : public EditUIObject
 400 {
 401     VclPtr<SpinField> mxSpinField;
 402
 403 public:
 404
 405     SpinFieldUIObject(const VclPtr<SpinField>& xEdit);
 406     virtual ~SpinFieldUIObject() override;
 407
 408     virtual void execute(const OUString& rAction,
 409             const StringMap& rParameters) override;
 410
 411     virtual StringMap get_state() override;
 412
 413     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 414
 415     virtual OUString get_action(VclEventId nEvent) const override;
 416
 417 private:
 418
 419     virtual OUString get_name() const override;
 420 };
 421
 422 class TabControlUIObject final : public WindowUIObject
 423 {
 424 private:
 425     VclPtr<TabControl> mxTabControl;
 426
 427 public:
 428
 429     TabControlUIObject(const VclPtr<TabControl>& mxTabControl);
 430     virtual ~TabControlUIObject() override;
 431
 432     virtual void execute(const OUString& rAction,
 433             const StringMap& rParameters) override;
 434
 435     virtual StringMap get_state() override;
 436
 437     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 438
 439     virtual OUString get_action(VclEventId nEvent) const override;
 440
 441 private:
 442
 443     virtual OUString get_name() const override;
 444 };
 445
 446 class VerticalTabControlUIObject final : public WindowUIObject
 447 {
 448 private:
 449     VclPtr<VerticalTabControl> mxTabControl;
 450
 451 public:
 452
 453     VerticalTabControlUIObject(const VclPtr<VerticalTabControl>& mxTabControl);
 454     virtual ~VerticalTabControlUIObject() override;
 455
 456     virtual void execute(const OUString& rAction,
 457             const StringMap& rParameters) override;
 458
 459     virtual StringMap get_state() override;
 460
 461     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 462
 463 private:
 464
 465     virtual OUString get_name() const override;
 466 };
 467
 468 class TreeListUIObject : public WindowUIObject
 469 {
 470 public:
 471     TreeListUIObject(const VclPtr<SvTreeListBox>& xTreeList);
 472
 473     virtual StringMap get_state() override;
 474
 475     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 476
 477     virtual void execute(const OUString& rAction,
 478             const StringMap& rParameters) override;
 479
 480     virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override;
 481
 482     virtual std::set<OUString> get_children() const override;
 483
 484 protected:
 485
 486     virtual OUString get_name() const override;
 487
 488     VclPtr<SvTreeListBox> mxTreeList;
 489 };
 490
 491 class TreeListEntryUIObject final : public UIObject
 492 {
 493 public:
 494
 495     TreeListEntryUIObject(const VclPtr<SvTreeListBox>& xTreeList, std::vector<sal_Int32> nTreePath);
 496
 497     virtual StringMap get_state() override;
 498
 499     virtual void execute(const OUString& rAction,
 500             const StringMap& rParameters) override;
 501
 502     virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override;
 503
 504     virtual std::set<OUString> get_children() const override;
 505
 506     virtual OUString get_type() const override;
 507
 508 private:
 509
 510     SvTreeListEntry* getEntry() const;
 511
 512     VclPtr<SvTreeListBox> mxTreeList;
 513
 514     std::vector<sal_Int32> maTreePath;
 515 };
 516
 517 class IconViewUIObject final : public TreeListUIObject
 518 {
 519 public:
 520     IconViewUIObject(const VclPtr<SvTreeListBox>& xIconView);
 521
 522     virtual StringMap get_state() override;
 523
 524     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 525
 526 private:
 527
 528     virtual OUString get_name() const override;
 529 };
 530
 531 class ToolBoxUIObject final : public WindowUIObject
 532 {
 533 private:
 534     VclPtr<ToolBox> mxToolBox;
 535
 536 public:
 537
 538     ToolBoxUIObject(const VclPtr<ToolBox>& mxToolBox);
 539     virtual ~ToolBoxUIObject() override;
 540
 541     virtual void execute(const OUString& rAction,
 542             const StringMap& rParameters) override;
 543
 544     virtual StringMap get_state() override;
 545
 546     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 547
 548     virtual OUString get_action(VclEventId nEvent) const override;
 549
 550 private:
 551
 552     virtual OUString get_name() const override;
 553 };
 554
 555 class MenuButtonUIObject final : public WindowUIObject
 556 {
 557     VclPtr<MenuButton> mxMenuButton;
 558
 559 public:
 560
 561     MenuButtonUIObject(const VclPtr<MenuButton>& xMenuButton);
 562     virtual ~MenuButtonUIObject() override;
 563
 564     virtual StringMap get_state() override;
 565
 566     virtual void execute(const OUString& rAction,
 567             const StringMap& rParameters) override;
 568
 569     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 570
 571 private:
 572
 573     virtual OUString get_name() const override;
 574 };
 575
 576 class UITEST_DLLPUBLIC DrawingAreaUIObject : public WindowUIObject
 577 {
 578 private:
 579     VclPtr<VclDrawingArea> mxDrawingArea;
 580 protected:
 581     weld::CustomWidgetController* mpController;
 582 public:
 583     DrawingAreaUIObject(const VclPtr<vcl::Window>& rDrawingArea);
 584     virtual ~DrawingAreaUIObject() override;
 585     virtual void execute(const OUString& rAction, const StringMap& rParameters) override;
 586     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 587 };
 588
 589 #endif
 590
 591 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */