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