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: */
567