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      * Does this represent the same underlying UI widget as rOther?
 119      */
 120     virtual bool equals(const UIObject& rOther) const = 0;
 121 };
 122
 123 class UITEST_DLLPUBLIC WindowUIObject : public UIObject
 124 {
 125     VclPtr<vcl::Window> mxWindow;
 126
 127 public:
 128
 129     WindowUIObject(const VclPtr<vcl::Window>& xWindow);
 130
 131     virtual StringMap get_state() override;
 132
 133     virtual void execute(const OUString& rAction,
 134             const StringMap& rParameters) override;
 135
 136     virtual OUString get_type() const override;
 137
 138     virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override;
 139
 140     std::unique_ptr<UIObject> get_visible_child(const OUString& rID);
 141
 142     virtual std::set<OUString> get_children() const override;
 143
 144     virtual OUString dumpState() const override;
 145
 146     virtual OUString dumpHierarchy() const override;
 147
 148     virtual OUString get_action(VclEventId nEvent) const override;
 149
 150     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 151
 152     virtual bool equals(const UIObject& rOther) const override;
 153
 154 protected:
 155
 156     virtual OUString get_name() const;
 157
 158 };
 159
 160 // TODO: moggi: what about push buttons?
 161 class ButtonUIObject final : public WindowUIObject
 162 {
 163     VclPtr<Button> mxButton;
 164 public:
 165
 166     ButtonUIObject(const VclPtr<Button>& xButton);
 167     virtual ~ButtonUIObject() override;
 168
 169     virtual StringMap get_state() override;
 170
 171     virtual void execute(const OUString& rAction,
 172             const StringMap& rParameters) override;
 173
 174     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 175
 176     virtual OUString get_action(VclEventId nEvent) const override;
 177
 178 private:
 179
 180     virtual OUString get_name() const override;
 181 };
 182
 183 class DialogUIObject final : public WindowUIObject
 184 {
 185     VclPtr<Dialog> mxDialog;
 186
 187 public:
 188
 189     DialogUIObject(const VclPtr<Dialog>& xDialog);
 190     virtual ~DialogUIObject() override;
 191
 192     virtual StringMap get_state() override;
 193
 194     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 195
 196 private:
 197
 198     virtual OUString get_name() const override;
 199 };
 200
 201 class EditUIObject : public WindowUIObject
 202 {
 203     VclPtr<Edit> mxEdit;
 204
 205 public:
 206
 207     EditUIObject(const VclPtr<Edit>& xEdit);
 208     virtual ~EditUIObject() override;
 209
 210     virtual void execute(const OUString& rAction,
 211             const StringMap& rParameters) override;
 212
 213     virtual StringMap get_state() override;
 214
 215     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 216
 217     virtual OUString get_action(VclEventId nEvent) const override;
 218
 219 protected:
 220
 221     virtual OUString get_name() const override;
 222 };
 223
 224 class MultiLineEditUIObject final : public WindowUIObject
 225 {
 226     VclPtr<VclMultiLineEdit> mxEdit;
 227
 228 public:
 229
 230     MultiLineEditUIObject(const VclPtr<VclMultiLineEdit>& xEdit);
 231     virtual ~MultiLineEditUIObject() override;
 232
 233     virtual void execute(const OUString& rAction,
 234             const StringMap& rParameters) override;
 235
 236     virtual StringMap get_state() override;
 237
 238     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 239
 240 private:
 241
 242     virtual OUString get_name() const override;
 243 };
 244
 245 class ExpanderUIObject final : public WindowUIObject
 246 {
 247     VclPtr<VclExpander> mxExpander;
 248
 249 public:
 250
 251     ExpanderUIObject(const VclPtr<VclExpander>& xExpander);
 252     virtual ~ExpanderUIObject() override;
 253
 254     virtual void execute(const OUString& rAction,
 255             const StringMap& rParameters) override;
 256
 257     virtual StringMap get_state() override;
 258
 259     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 260 private:
 261
 262     virtual OUString get_name() const override;
 263 };
 264
 265
 266 // TODO: moggi: maybe let it inherit from the button case
 267 class CheckBoxUIObject final : public WindowUIObject
 268 {
 269 private:
 270     VclPtr<CheckBox> mxCheckBox;
 271
 272 public:
 273     CheckBoxUIObject(const VclPtr<CheckBox>& xCheckbox);
 274     virtual ~CheckBoxUIObject() override;
 275
 276     virtual void execute(const OUString& rAction,
 277             const StringMap& rParameters) override;
 278
 279     virtual StringMap get_state() override;
 280
 281     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 282
 283     virtual OUString get_action(VclEventId nEvent) const override;
 284
 285 private:
 286
 287     virtual OUString get_name() const override;
 288 };
 289
 290 class RadioButtonUIObject final : public WindowUIObject
 291 {
 292 private:
 293     VclPtr<RadioButton> mxRadioButton;
 294
 295 public:
 296     RadioButtonUIObject(const VclPtr<RadioButton>& xCheckbox);
 297     virtual ~RadioButtonUIObject() override;
 298
 299     virtual void execute(const OUString& rAction,
 300             const StringMap& rParameters) override;
 301
 302     virtual StringMap get_state() override;
 303
 304     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 305
 306     virtual OUString get_action(VclEventId nEvent) const override;
 307
 308 private:
 309
 310     virtual OUString get_name() const override;
 311 };
 312
 313 class TabPageUIObject final : public WindowUIObject
 314 {
 315 private:
 316     VclPtr<TabPage> mxTabPage;
 317 public:
 318     TabPageUIObject(const VclPtr<TabPage>& xTabPage);
 319     virtual ~TabPageUIObject() override;
 320
 321     virtual void execute(const OUString& rAction,
 322             const StringMap& rParameters) override;
 323
 324     virtual StringMap get_state() override;
 325
 326     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 327
 328 private:
 329
 330     virtual OUString get_name() const override;
 331 };
 332
 333 class ListBoxUIObject final : public WindowUIObject
 334 {
 335 private:
 336     VclPtr<ListBox> mxListBox;
 337
 338 public:
 339
 340     ListBoxUIObject(const VclPtr<ListBox>& xListBox);
 341     virtual ~ListBoxUIObject() override;
 342
 343     virtual void execute(const OUString& rAction,
 344             const StringMap& rParameters) override;
 345
 346     virtual StringMap get_state() override;
 347
 348     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 349
 350     virtual OUString get_action(VclEventId nEvent) const override;
 351
 352 private:
 353
 354     virtual OUString get_name() const override;
 355 };
 356
 357 // TODO: moggi: should it inherit from EditUIObject?
 358 class ComboBoxUIObject final : public WindowUIObject
 359 {
 360 private:
 361     VclPtr<ComboBox> mxComboBox;
 362
 363 public:
 364
 365     ComboBoxUIObject(const VclPtr<ComboBox>& xListBox);
 366     virtual ~ComboBoxUIObject() override;
 367
 368     virtual void execute(const OUString& rAction,
 369             const StringMap& rParameters) override;
 370
 371     virtual StringMap get_state() override;
 372
 373     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 374
 375     virtual OUString get_action(VclEventId nEvent) const override;
 376
 377 private:
 378
 379     virtual OUString get_name() const override;
 380 };
 381
 382 class SpinUIObject final : public WindowUIObject
 383 {
 384 private:
 385     VclPtr<SpinButton> mxSpinButton;
 386
 387 public:
 388
 389     SpinUIObject(const VclPtr<SpinButton>& xSpinButton);
 390     virtual ~SpinUIObject() override;
 391
 392     virtual void execute(const OUString& rAction,
 393             const StringMap& rParameters) override;
 394
 395     virtual StringMap get_state() override;
 396
 397     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 398
 399     virtual OUString get_action(VclEventId nEvent) const override;
 400
 401 private:
 402
 403     virtual OUString get_name() const override;
 404 };
 405
 406 class SpinFieldUIObject : public EditUIObject
 407 {
 408     VclPtr<SpinField> mxSpinField;
 409
 410 public:
 411
 412     SpinFieldUIObject(const VclPtr<SpinField>& xEdit);
 413     virtual ~SpinFieldUIObject() override;
 414
 415     virtual void execute(const OUString& rAction,
 416             const StringMap& rParameters) override;
 417
 418     virtual StringMap get_state() override;
 419
 420     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 421
 422     virtual OUString get_action(VclEventId nEvent) const override;
 423
 424 private:
 425
 426     virtual OUString get_name() const override;
 427 };
 428
 429 class TabControlUIObject final : public WindowUIObject
 430 {
 431 private:
 432     VclPtr<TabControl> mxTabControl;
 433
 434 public:
 435
 436     TabControlUIObject(const VclPtr<TabControl>& mxTabControl);
 437     virtual ~TabControlUIObject() override;
 438
 439     virtual void execute(const OUString& rAction,
 440             const StringMap& rParameters) override;
 441
 442     virtual StringMap get_state() override;
 443
 444     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 445
 446     virtual OUString get_action(VclEventId nEvent) const override;
 447
 448 private:
 449
 450     virtual OUString get_name() const override;
 451 };
 452
 453 class VerticalTabControlUIObject final : public WindowUIObject
 454 {
 455 private:
 456     VclPtr<VerticalTabControl> mxTabControl;
 457
 458 public:
 459
 460     VerticalTabControlUIObject(const VclPtr<VerticalTabControl>& mxTabControl);
 461     virtual ~VerticalTabControlUIObject() override;
 462
 463     virtual void execute(const OUString& rAction,
 464             const StringMap& rParameters) override;
 465
 466     virtual StringMap get_state() override;
 467
 468     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 469
 470 private:
 471
 472     virtual OUString get_name() const override;
 473 };
 474
 475 class TreeListUIObject : public WindowUIObject
 476 {
 477 public:
 478     TreeListUIObject(const VclPtr<SvTreeListBox>& xTreeList);
 479
 480     virtual StringMap get_state() override;
 481
 482     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 483
 484     virtual void execute(const OUString& rAction,
 485             const StringMap& rParameters) override;
 486
 487     virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override;
 488
 489     virtual std::set<OUString> get_children() const override;
 490
 491 protected:
 492
 493     virtual OUString get_name() const override;
 494
 495     VclPtr<SvTreeListBox> mxTreeList;
 496 };
 497
 498 class TreeListEntryUIObject final : public UIObject
 499 {
 500 public:
 501
 502     TreeListEntryUIObject(const VclPtr<SvTreeListBox>& xTreeList, std::vector<sal_Int32> nTreePath);
 503
 504     virtual StringMap get_state() override;
 505
 506     virtual void execute(const OUString& rAction,
 507             const StringMap& rParameters) override;
 508
 509     virtual std::unique_ptr<UIObject> get_child(const OUString& rID) override;
 510
 511     virtual std::set<OUString> get_children() const override;
 512
 513     virtual OUString get_type() const override;
 514
 515     virtual bool equals(const UIObject& rOther) const override;
 516
 517 private:
 518
 519     SvTreeListEntry* getEntry() const;
 520
 521     VclPtr<SvTreeListBox> mxTreeList;
 522
 523     std::vector<sal_Int32> maTreePath;
 524 };
 525
 526 class IconViewUIObject final : public TreeListUIObject
 527 {
 528 public:
 529     IconViewUIObject(const VclPtr<SvTreeListBox>& xIconView);
 530
 531     virtual StringMap get_state() override;
 532
 533     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 534
 535 private:
 536
 537     virtual OUString get_name() const override;
 538 };
 539
 540 class ToolBoxUIObject final : public WindowUIObject
 541 {
 542 private:
 543     VclPtr<ToolBox> mxToolBox;
 544
 545 public:
 546
 547     ToolBoxUIObject(const VclPtr<ToolBox>& mxToolBox);
 548     virtual ~ToolBoxUIObject() override;
 549
 550     virtual void execute(const OUString& rAction,
 551             const StringMap& rParameters) override;
 552
 553     virtual StringMap get_state() override;
 554
 555     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 556
 557     virtual OUString get_action(VclEventId nEvent) const override;
 558
 559 private:
 560
 561     virtual OUString get_name() const override;
 562 };
 563
 564 class MenuButtonUIObject final : public WindowUIObject
 565 {
 566     VclPtr<MenuButton> mxMenuButton;
 567
 568 public:
 569
 570     MenuButtonUIObject(const VclPtr<MenuButton>& xMenuButton);
 571     virtual ~MenuButtonUIObject() override;
 572
 573     virtual StringMap get_state() override;
 574
 575     virtual void execute(const OUString& rAction,
 576             const StringMap& rParameters) override;
 577
 578     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 579
 580 private:
 581
 582     virtual OUString get_name() const override;
 583 };
 584
 585 class UITEST_DLLPUBLIC DrawingAreaUIObject : public WindowUIObject
 586 {
 587 private:
 588     VclPtr<VclDrawingArea> mxDrawingArea;
 589 protected:
 590     weld::CustomWidgetController* mpController;
 591 public:
 592     DrawingAreaUIObject(const VclPtr<vcl::Window>& rDrawingArea);
 593     virtual ~DrawingAreaUIObject() override;
 594     virtual void execute(const OUString& rAction, const StringMap& rParameters) override;
 595     static std::unique_ptr<UIObject> create(vcl::Window* pWindow);
 596 };
 597
 598 #endif
 599
 600 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */