aboutsummaryrefslogtreecommitdiffstats
path: root/src/lib/elementary/efl_ui_win.eo
blob: cd24a5cfb0fd6bfa6b8fdfed7253e117f677395b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837

enum Efl.Ui.Win.Type
{
   [[Defines the types of window that can be created

     These are hints set on the window so that a running Window Manager knows
     how the window should be handled and/or what kind of decorations it
     should have.

     Currently, only the X11 backed engines use them.
   ]]
   legacy: efl_ui_win;

   unknown = -1,
   basic, [[A normal window. Indicates a normal, top-level window. Almost every
            window will be created with this type.]]
   dialog_basic, [[Used for simple dialog windows.]]
   desktop, [[For special desktop windows, like a background window holding
              desktop icons.]]
   dock, [[The window is used as a dock or panel. Usually would be kept on top
           of any other window by the Window Manager.]]
   toolbar, [[The window is used to hold a floating toolbar, or similar.]]
   menu, [[Similar to #ELM_WIN_TOOLBAR.]]
   utility, [[A persistent utility window, like a toolbox or palette.]]
   splash, [[Splash window for a starting up application.]]
   dropdown_menu, [[The window is a dropdown menu, as when an  entry in a
                    menubar is clicked.
                    This hint exists for completion only, as the EFL way of
                    implementing a menu would not normally use a separate
                    window for its contents.]]
   popup_menu, [[Like #ELM_WIN_DROPDOWN_MENU, but for the menu triggered by
                 right-clicking an object.]]
   tooltip, [[The window is a tooltip. A short piece of explanatory text that
              typically appear after the mouse cursor hovers over an object
              for a while. Typically not very commonly used in the EFL.]]
   notification, [[A notification window, like a warning about battery life or
                   a new E-Mail received.]]
   combo, [[A window holding the contents of a combo box. Not usually used in
            the EFL.]]
   dnd, [[Used to indicate the window is a representation of an object being
          dragged across different windows, or even applications. Typically
          used with elm_win_override_set().]]
   inlined_image, [[The window is rendered onto an image buffer. No actual
                    window is created for this type, instead the window and
                    all of its contents will be rendered to an image buffer.
                    This allows to have children window inside a parent one
                    just like any other object would be, and do other things
                    like applying \@ref Evas_Map effects to it. This is the only
                    type of window that requires the parent parameter of
                    \@ref elm_win_add to be a valid @Evas.Object.]]
   socket_image, [[The window is rendered onto an image buffer and can be shown
                   other process's plug image object. No actual window is
                   created for this type, instead the window and all of its
                   contents will be rendered to an image buffer and can be
                   shown other process's plug image object.
                 ]]
   fake [[This window was created using a pre-existing canvas. The window
          widget can be deleted, but the canvas must be managed externally.

          @since 1.13
        ]]
}

enum Efl.Ui.Win.Keyboard_Mode
{
   [[The different layouts that can be requested for the virtual keyboard.

     When the application window is being managed by Illume, it may request
     any of the following layouts for the virtual keyboard.
   ]]
   legacy: efl_ui_win_keyboard;

   unknown, [[Unknown keyboard state]]
   off, [[Request to deactivate the keyboard]]
   on, [[Enable keyboard with default layout]]
   alpha, [[Alpha (a-z) keyboard layout]]
   numeric, [[Numeric keyboard layout]]
   pin, [[PIN keyboard layout]]
   phone_number, [[Phone keyboard layout]]
   hex, [[Hexadecimal numeric keyboard layout]]
   terminal, [[Full (QWERTY) keyboard layout]]
   password, [[Password keyboard layout]]
   ip, [[IP keyboard layout]]
   host, [[Host keyboard layout]]
   file, [[File keyboard layout]]
   url, [[URL keyboard layout]]
   keypad, [[Keypad layout]]
   j2me [[J2ME keyboard layout]]
}

enum Efl.Ui.Win.Indicator_Type
{
   [[Defines the type indicator that can be shown]]
   legacy: efl_ui_win_indicator;

   type_unknown, [[Unknown indicator type]]
   bg_opaque, [[The icon of indicator is opaque, the background of indicator is also opaque. 
                The content of window is located the end of indicator.
                The area of indicator and window content are not overlapped]]
   bg_transparent, [[The icon of indicator is opaque, but the background is transparent.
                     The content of window is located under the indicator in Z-order.
                     The area of indicator and window content are overlapped]]
   hidden [[The indicator is hidden, So user can see only the content of window like the video mode.
            If user flicks the upper side of window, the incator is shown temporarily.]]
}

/**
 */
enum Efl.Ui.Win.Keygrab_Mode
{
   [[Define the keygrab modes of window. A window may send commands to the
     Keyrouter according this mode, and perform different actions.]]

   legacy: efl_ui_win_keygrab;
   unknown = 0, [[Unknown keygrab mode]]
   shared = (1 << 8), [[Getting the grabbed-key together with the other client
                        windows]]
   topmost = (1 << 9), [[Getting the grabbed-key only when window is top of the
                         stack]]
   exclusive = (1 << 10), [[Getting the grabbed-key exclusively regardless of
                            window's position]]
   override_exclusive = (1 << 11) [[Getting the grabbed-key exclusively
                                    regardless of window's position. Being
                                    overrided the grab by the other client
                                    window]]
}

enum Efl.Ui.Win.Modal_Mode
{
   [[Defines the mode of a modal window]]
   legacy: efl_ui_win_modal;

   none, [[The window is not modal window.]]
   modal [[The window is modal window.]]
}

enum Efl.Ui.Win.Urgent_Mode
{
   [[Defines the mode of a urgent window.]]
   legacy: efl_ui_win_urgent;

   none,  [[The window is not a urgent window.]]
   urgent [[The window is a urgent window.]]
}

class Efl.Ui.Win (Elm.Widget, Efl.Canvas, Elm.Interface.Atspi.Window,
               Elm.Interface.Atspi_Widget_Action, Efl.Pack,
               Efl.Input.State, Efl.Input.Interface, Efl.Screen,
               Efl.Gfx.Size.Hint, Efl.Text)
{
   legacy_prefix: elm_win;
   eo_prefix: efl_ui_win;
   event_prefix: efl_ui_win;
   methods {
      @property indicator_enabled {
         set {
             [[In some environments, like phones, you may have an indicator that
               shows battery status, reception, time etc. This is the indicator.

               Sometimes you don't want it because you provide the same functionality
               inside your app, so this will request that the indicator is disabled in
               this circumstance. The default is depend on the environments.
               For example, like phones, default is to enable the indicator.
               But like TV, default is to disable the indicator.

               Sets the indicator enable of the window.]]
            legacy: null;
         }
         get {
            [[Get the indicator enable of the window.]]
            legacy: null;
         }
         values {
            enabled: bool; [[If true, the indicator is enabled,
                             If false, the indicator is disabled.]]
         }
      }
      @property indicator_type {
         set {
            [[Sets the indicator type of the window.]]
            legacy: null;
         }
         get {
            [[Get the indicator type of the window.]]
            legacy: null;
         }
         values {
            type: Efl.Ui.Win.Indicator_Type; [[The type, one of #Efl_Ui_Win_Indicator_Type.]]
         }
      }
      @property keyboard_mode {
         set {
            [[Sets the keyboard mode of the window.]]
         }
         get {
            [[Get the keyboard mode of the window.]]
         }
         values {
            mode: Efl.Ui.Win.Keyboard_Mode; [[The mode, one of #Efl_Ui_Win_Keyboard_Mode.]]
         }
      }
      @property wm_available_rotations {
         set {
            [[Set the array of available window rotations.

              This function is used to set the available rotations to give
              the hints to WM. WM will refer this hints and set the
              orientation window properly.

              @since 1.9
            ]]
            legacy: elm_win_wm_rotation_available_rotations_set;
            values {
               rotations: const(int)*; [[The array of rotation value.]]
               count: uint; [[The size of the rotations array.]]
            }
         }
         get {
            [[Get the array of available window rotations.

              This function is used to get the available rotations.

              @since 1.9
            ]]
            legacy: elm_win_wm_rotation_available_rotations_get;
            values {
               rotations: int*; [[The array of rotation value.]]
               count: uint; [[The size of the rotations array.]]
            }
            return: bool;
         }
      }
      @property screen_constrain {
         set {
            [[Constrain the maximum width and height of a window to the
              width and height of its screen.

              When $constrain is $true, $obj will never resize larger than
              the screen.
            ]]
         }
         get {
            [[Get the constraints on the maximum width and height of a
              window relative to the width and height of its screen.

              When this function returns $true, $obj will never resize
              larger than the screen.
            ]]
         }
         values {
            constrain: bool; [[$true to restrict the window's maximum size.]]
         }
      }
      @property focus_highlight_style {
         set {
            [[Set the style for the focus highlight on this window.

              Sets the style to use for theming the highlight of focused
              objects on the given window. If $style is NULL, the default
              will be used.
            ]]
         }
         get {
            [[Get the style set for the focus highlight object.]]
         }
         values {
            style: string @nullable; [[The style or $null if none.]]
         }
      }
      @property focus_highlight_enabled {
         set {
            [[Set the enabled status for the focus highlight in a window.

              This function will enable or disable the focus highlight only
              for the given window, regardless of the global setting for it.
            ]]
         }
         get {
            [[Get the enabled value of the focus highlight for this window.]]
         }
         values {
            enabled: bool; [[The enabled value for the highlight.]]
         }
      }
      @property focus_highlight_animate {
         set {
            [[Set the animate status for the focus highlight for this window.

              This function will enable or disable the animation of focus
              highlight only for the given window, regardless of the
              global setting for it.
            ]]
         }
         get {
            [[Get the animate value of the focus highlight for this window.]]
         }
         values {
            animate: bool; [[The enabled value for the highlight animation.]]
         }
      }
      @property prop_focus_skip {
         set {
            [[Set the window to be skipped by keyboard focus.

              This sets the window to be skipped by normal keyboard input.
              This means a window manager will be asked to not focus this
              window as well as omit it from things like the taskbar, pager,
              "alt-tab" list etc. etc.

              Call this and enable it on a window BEFORE you show it for
              the first time, otherwise it may have no effect.

              Use this for windows that have only output information or
              might only be interacted with by the mouse or fingers, and
              never for typing input. Be careful that this may have
              side-effects like making the window non-accessible in
              some cases unless the window is specially handled. Use
              this with care.
            ]]
         }
         values {
            skip: bool; [[The skip flag state ($true if it is to be skipped).]]
         }
      }
      @property focus {
         get {
            [[Get whether a window has focus.]]
            return: bool;
         }
      }
      @property autodel {
         set {
            [[Set the window's autodel state.

              When closing the window in any way outside of the program
              control, like pressing the X button in the titlebar or using
              a command from the Window Manager, a "delete,request" signal
              is emitted to indicate that this event occurred and the
              developer can take any action, which may include, or not,
              destroying the window object.

              When the $autodel parameter is set, the window will be
              automatically destroyed when this event occurs, after the
              signal is emitted. If $autodel is $false, then the window
              will not be destroyed and is up to the program to do so
              when it's required.
            ]]
         }
         get {
            [[Get the window's autodel state.]]
         }
         values {
            autodel: bool; [[If true, the window will automatically delete
                             itself when closed.]]
         }
      }
      @property autohide {
         [[Window's autohide state.

           This property works similarly to @.autodel, automatically handling
           "delete,request" signals when set to $trze, with the difference
           that it will hide the window, instead of destroying it.

           It is specially designed to work together with $ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN
           which allows exiting Elementary's main loop when all the windows
           are hidden.

           Note: @.autodel and $autohide are not mutually exclusive. The window
           will be deleted if both are set to $true.
         ]]

         set {
         }
         get {
         }
         values {
            autohide: bool; [[If true, the window will automatically hide
                              itself when closed.]]
         }
      }
      @property icon_object {
         set {
            [[Set a window object's icon.

              This sets an image to be used as the icon for the given
              window, in the window manager decoration part. The exact
              pixel dimensions of the object (not object size) will be
              used, and the image pixels will be used as-is when this
              function is called. If the image object has been updated,
              then call this function again to source the image pixels
              and put them on the window's icon. Note that only Evas
              image objects are allowed.
            ]]
            /* FIXME-doc
            Example of usage:
            @code
            icon = evas_object_image_add(evas_object_evas_get(elm_window));
            evas_object_image_file_set(icon, "/path/to/the/icon", NULL);
            elm_win_icon_object_set(elm_window, icon);
            evas_object_show(icon);
            @endcode
            */
            values {
               icon: Evas.Object @nullable; [[The Evas image object to use for an icon.]]
            }
         }
         get {
            [[Get the icon object used for the window.

              The object returns is the one marked by @.icon_object.set as
              the object to use for the window icon.
            ]]
            values {
               icon: const(Evas.Object) @nullable; [[The Evas image object to use for an icon.]]
            }
         }
      }
      @property iconified {
         set {
            [[Set the iconified state of a window.]]
         }
         get {
            [[Get the iconified state of a window.]]
         }
         values {
            iconified: bool; [[If true, the window is iconified.]]
         }
      }
      @property maximized {
         set {
            [[Set the maximized state of a window.]]
         }
         get {
            [[Get the maximized state of a window.]]
         }
         values {
            maximized: bool; [[If true, the window is maximized.]]
         }
      }
      @property fullscreen {
         set {
            [[Set the fullscreen state of a window.]]
         }
         get {
            [[Get the fullscreen state of a window.]]
         }
         values {
            fullscreen: bool; [[If $true, the window is fullscreen.]]
         }
      }
      @property sticky {
         set {
            [[Set the sticky state of the window.

              Hints the Window Manager that the window in $obj should be
              left fixed at its position even when the virtual desktop
              it's on moves or changes.
            ]]
         }
         get {
            [[Get the sticky state of the window.]]
         }
         values {
            sticky: bool; [[If true, the window's sticky state is enabled.]]
         }
      }
      @property urgent {
         set {
            [[Set the urgent state of a window.]]
            legacy: null;
         }
         get {
            [[Get the urgent state of a window.]]
            legacy: null;
         }
         values {
            urgent: Efl.Ui.Win.Urgent_Mode;
                [[The mode of a urgent window, one of #Efl_Ui_Win_Urgent_Mode.]]
         }
      }
      @property modal {
         set {
            [[Set the modal state of a window.]]
            legacy: null;
         }
         get {
            [[Get the modal state of a window.]]
            legacy: null;
         }
         values {
            modal: Efl.Ui.Win.Modal_Mode; [[The mode of a window, one of #Efl_Ui_Win_Modal_Mode.]]
         }
      }
      @property noblank {
         set {
            [[Set the noblank property of a window.

              The "noblank" property is a way to request the display on
              which the windowis shown does not blank, screensave or
              otherwise hide or obscure the window. It is intended for
              uses such as media playback on a television where a user
              may not want to be interrupted by an idle screen. The
              noblank property may have no effect if the window is
              iconified/minimized or hidden.

              @since 1.11
            ]]
         }
         get {
            [[Get the noblank property of a window.

              @since 1.11
            ]]
         }
         values {
            noblank: bool; [[If true, the window is set to noblank.]]
         }
      }
      @property borderless {
         set {
            [[Set the borderless state of a window.

              This function requests the Window Manager to not draw any
              decoration around the window.
            ]]
         }
         get {
            [[Get the borderless state of a window.]]
         }
         values {
            borderless: bool; [[If true, the window is borderless.]]
         }
      }
      @property role {
         set {
            [[Set the role of the window.]]
         }
         get {
            [[Get the role of the window.

              The returned string is an internal one and should not be
              freed or modified. It will also be invalid if a new role
              is set or if the window is destroyed.
            ]]
         }
         values {
            role: string; [[The role to set.]]
         }
      }
      @property name {
         [[The window name.

           The meaning of name depends on the underlying windowing system.

           The window name is a constructing property that need to be set at
           creation within \@ref eo_add.

           Note: Once set, it can NOT be modified afterward.
         ]]
         /* FIXME-doc
         Example:
         @code
         win = eo_add(ELM_WIN_CLASS, NULL, elm_obj_win_name_set(ELM_WIN_BASIC));
         @endcode
         */
         set {
            [[Can only be used at creation time, within \@ref eo_add.]]
            legacy: null;
         }
         get {}
         values {
            name: string @nullable;
         }
      }
      @property type {
         [[The type of the window.

           It is a hint of how the Window Manager should handle it.

           The window type is a constructing property that need to be set at
           creation within \@ref eo_add.

           Note: Once set, it can NOT be modified afterward.
         ]]
         /* FIXME-doc
         Example:
         @code
         win = eo_add(ELM_WIN_CLASS, NULL, elm_obj_win_type_set(ELM_WIN_BASIC));
         @endcode
         */
         set {
            [[Can only be used at creation time, within \@ref eo_add.]]
            legacy: null;
         }
         get {
            [[If the object is not window object, return #ELM_WIN_UNKNOWN.]]
         }
         values {
            type: Efl.Ui.Win.Type(Efl.Ui.Win.Type.unknown);
         }
      }
      @property available_profiles {
         set {
            [[Set the array of available profiles to a window.

              @since 1.8
            ]]
            values {
               profiles: string*; [[The string array of available profiles.]]
               count: uint; [[The number of members in profiles.]]
            }
         }
         get {
            [[Get the array of available profiles of a window.

              @since 1.8
            ]]
            values {
               profiles: char**; [[The string array of available profiles.]]
               count: uint; [[The number of members in profiles.]]
            }
            return: bool;
         }
      }
      @property alpha {
         set {
            [[Set the alpha channel state of a window.

              If $alpha is true, the alpha channel of the canvas will be
              enabled possibly making parts of the window completely or
              partially transparent. This is also subject to the underlying
              system supporting it, like for example, running under a
              compositing manager.

              Note: Alpha window can be enabled automatically by window
              theme style's property. If "alpha" data.item is "1" or
              "true" in window style(eg. elm/win/base/default), the window
              is switched to alpha automatically without the explicit api
              call.
            ]]
         }
         get {
            [[Get the alpha channel state of a window.]]
         }
         values {
            alpha: bool; [[$true if the window alpha channel is enabled,
                           $false otherwise.]]
         }
      }
      socket_listen {
         [[Create a socket to provide the service for Plug widget.]]
         return: bool;
         params {
            @in svcname: string; [[The name of the service to be advertised.
                                         Eensure that it is unique (when combined with
                                         $svcnum) otherwise creation may fail.]]
            @in svcnum: int; [[A number (any value, 0 being the common default) to
                               differentiate multiple instances of services with
                               the same name.]]
            @in svcsys: bool; [[A boolean that if true, specifies to create a
                                system-wide service all users can connect to,
                                otherwise the service is private to the user
                                id that created the service.]]
         }
      }
      activate {
         [[Activate a window object.

           This function sends a request to the Window Manager to activate
           the window pointed by $obj. If honored by the WM, the window
           will receive the keyboard focus.

           Note: This is just a request that a Window Manager may ignore,
           so calling this function does not ensure in any way that the
           window will be the active one after it.
         ]]
      }
      raise {
         [[Raise a window object.

           Places the window pointed by $obj at the top of the stack, so
           that it's not covered by any other window.
         ]]
      }
      center {
         [[Center a window on its screen

           This function centers window $obj horizontally and/or vertically
           based on the values of $h and $v.
         ]]

         params {
            @in h: bool; [[If true, center horizontally. If false, do not change horizontal location.]]
            @in v: bool; [[If true, center vertically. If false, do not change vertical location.]]
         }
      }
      keygrab_set {
         [[Set keygrab value of the window

           This function grabs the $key of window using $grab_mode.
         ]]

         return: bool;
         params {
            @in key: string; [[This string is the keyname to grab.]]
            @in modifiers: Evas.Modifier_Mask; [[This is for the keymask feature. Currently this feature is not supported.]]
            @in not_modifiers: Evas.Modifier_Mask; [[This is for the keymask feature. Currently this feature is not supported.]]
            @in proirity: int; [[This is for the priority of keygrab. Currently this feature is not supported.]]
            @in grab_mode: Efl.Ui.Win.Keygrab_Mode; [[According to the grabmode, it can grab key differently.]]
         }
      }
      keygrab_unset {
         [[Unset keygrab value of the window

           This function unset keygrab value. Ungrab $key of window.
         ]]
         return: bool;
         params {
            @in key: string; [[This string is the keyname to grab.]]
            @in modifiers: Evas.Modifier_Mask; [[This is for the keymask feature. Currently this feature is not supported.]]
            @in not_modifiers: Evas.Modifier_Mask; [[This is for the keymask feature. Currently this feature is not supported.]]
         }
      }
      teamwork_uri_preload {
         [[Notify the compositor that a uri should be preloaded
           @since 1.18
         ]]
         params {
            @in uri: string; [[This is the uri to notify with]]
         }
      }
      teamwork_uri_show {
         [[Notify the compositor that a uri should be displayed

           Sends the current mouse coordinates as a hint for displaying the
           related uri in the compositor.
           @since 1.18
         ]]
         params {
            @in uri: string; [[This is the uri to notify with]]
         }
      }
      teamwork_uri_hide {
         [[Notify the compositor that a uri should be hidden

           Hides any uri-related media displayed in the compositor through
           previous \@ref elm_win_teamwork_uri_show request
           @since 1.18
         ]]
      }
      teamwork_uri_open {
         [[Notify the compositor that a uri should be opened

           Use the compositor's default application to open a uri
           @since 1.18
         ]]
         params {
            @in uri: string; [[This is the uri to open]]
         }
      }
   }
   implements {
      class.constructor;
      Eo.Base.constructor;
      Eo.Base.finalize;
      Evas.Object.Smart.smart_hide;
      Evas.Object.Smart.smart_show;
      Evas.Object.Smart.smart_move;
      Evas.Object.Smart.smart_add;
      Evas.Object.Smart.smart_del;
      Evas.Object.Smart.smart_resize;
      Elm.Widget.focus_direction;
      Elm.Widget.focus_next_manager_is;
      Elm.Widget.focus_direction_manager_is;
      Elm.Widget.focus_next;
      Elm.Widget.theme_apply;
      Elm.Widget.on_focus;
      Elm.Widget.event;
      Elm.Interface.Atspi_Accessible.parent.get;
      Elm.Interface.Atspi_Accessible.state_set.get;
      Elm.Interface.Atspi_Accessible.name.get;
      Elm.Interface.Atspi_Widget_Action.elm_actions.get;
      Efl.Container.content_remove;
      Efl.Container.content_iterate;
      Efl.Container.content_count;
      Efl.Pack.unpack;
      Efl.Pack.pack;
      Efl.Input.State.modifier_enabled.get;
      Efl.Input.State.lock_enabled.get;
      Efl.Screen.screen_dpi.get;
      Efl.Screen.screen_rotation.get;
      Efl.Screen.screen_size.get;
      Efl.Gfx.Size.Hint.hint_base.set;
      Efl.Gfx.Size.Hint.hint_base.get;
      Efl.Gfx.Size.Hint.hint_step.set;
      Efl.Gfx.Size.Hint.hint_step.get;
      Efl.Gfx.Size.Hint.hint_aspect.set;
      Efl.Gfx.Size.Hint.hint_aspect.get;
      Efl.Text.text.set;
      Efl.Text.text.get;
      Efl.Canvas.pointer_canvas_xy.get;
      Efl.Canvas.pointer_inside.get;
      Efl.Canvas.image_max_size.get;
      Efl.Canvas.image_cache.get;
      Efl.Canvas.image_cache.set;
      Efl.Canvas.font_cache.get;
      Efl.Canvas.font_cache.set;
      Efl.Canvas.smart_objects_calculate;
      Efl.Canvas.objects_at_xy_get;
      Efl.Canvas.object_top_at_xy_get;
      Efl.Canvas.objects_in_rectangle_get;
      Efl.Canvas.object_top_in_rectangle_get;
   }
   constructors {
      .name;
      .type;
   }
   events {
      delete,request;
      withdrawn;
      iconified;
      normal;
      stick;
      unstick;
      fullscreen;
      unfullscreen;
      maximized;
      unmaximized;
      ioerr;
      indicator,prop,changed;
      rotation,changed;
      profile,changed;
      wm,rotation,changed;
      theme,changed;
      elm,action,block_menu;
   }
}