aboutsummaryrefslogblamecommitdiffstats
path: root/src/lib/elementary/efl_ui_win.eo
blob: bca1b4a574fd7e6cacd2382b1005d5de82fc359c (plain) (tree)
1
2
3
4
5
6
7
8
9
10
                          
 
                                                     
 
                                                                           

                                                                        
 

                                                     
 
                                           






                                                                               

                                                                         


                                                                         

                                                                              

                                                                         
                                                                                   


                                                                             
                                                          

                                                                              
                                                                              
                      



                                   
                                                              

                                                                          
                          

 
                                   
 
                                                                          
 
                                                                          

                                                           
 















                                               

 
                              
 
                                                  
 

                 
                                                

                                                                             
                                                                              

                                                                                        
                                                                               

                                                                                                     

 
                                
 
                                          
 

                                              

 
                                 






                                                
                                
 
                                                
 
                                                                        
                                                                           

                 
                                                                
                                              








                       

                
     





                                                              

 
                                                                                      

                                                                                


                                                        
 
                         


                
            
                                
                                                                

                                                                            
                                                                                   
                                                                                  


                                                                               
           
              

              
          
                 
                                                                                             

          
                                     
                                             
              

              

                 
                                                                                           

          
                                              
                                                        
 









                                                                             

              

                                                                      

          
                                             

                                            

              




                                                                   
                                        

                                                                    
 



                                                                       

              




                                                                             
                                       
















                                                                         
              




                                                                               
                                

                                   







                                                                                
                                                                             
 


                                                                              
 
                                                                              
                                                    
           
                 
                                                                          
                                                   

          





                                                                                         
                                                                                            
                                 


                                                                                        

                 
                                                                                  

          
                             










                                                                         
              
                    
                                       
                                                          


              
                    
                                              
                                                               


             
                           
                                             
              

              

                 
                                                               

          
                           
                                             
              

              

                 
                                                                   

          
                            
                                              
              

              




                                                                     
                              
                                          
 




                                                                     

              

                 
                                                                             

          
                              
                                          
              

              

                 
                                           
                                                                                

          
                             
                                         
              

              

                 
                                                                                                  

          
                                  
                                            
 



                                                                    

              

                 
                                                                     

          
                                




                                                                           



                                                                   
           
              

              

                 
                                              

          
                          



                                                                          

                                                                             
 
                                                            
           
              
          
              
          
                 
                                         

          
                                



                                                                   

                                                                             
 
                                                           

                                                                                
           
              

              

                 
                                                                         

          
                                        

                                                                
                                                                       
                                





                                                                          


                                                                                             


                                                 
                                                    
                                                                                
                                                                         























                                                                                           
                                           
          
              
          
              

          
                       













                                                                        
              

              

                 

                                                                        

          
                                











                                                                         
              

                 

                                                                        


                                    
                                       
                                                              
 




                                                                     

              


                                                                       
                                                                        


                                    
                                  
                                              
 

                                                                     
                                                                      
                     
 
                                                                    
                                                     

               

                 

                                                                      

          
                          


                                                                     
                                  
       
                                                    



                                                                                                         
                                                                                            
                                 

                                                                                                 

                 
                                                                                   

          
                
                                    
 


                                                                          
 

                                                                         
                                                    
           
       
                    
                                         
 

                                                                           
 

                                                                         
                                              
           
                 

                                                                                                         

          

                                               
 
                                                                              
                                                                           











                                                                             
 




                                                                        








                                                                                      
 
                                                                      



                                                                               
           

                                                                          
                 
                                                                          
                                                                   

          





























                                                                               








                                                                                
                                                                                 













                                                                                      


                                      

                                                                                                           

              

              

                 
                                                         

          
                                         
                                                                                                      




                                              

              



















                                                                     
                                                                     








                                                         

              




                                                                             

               
                        
                             
                            
                               
                          
                                     


                                      


                                                                                 
                                
                                        
                                          
                                               
                                                       

                                          
                                           
                                                   



                                               
                                               
                                             


                                         
                                 

                                         
                                            
                                                
                                                
                                              
                                               
                                                         



                                                   

                                      

                                       
                        
    
                 


                                  
    
           
                                                                                
                                                                
                                                          
                                                                 

                                                                             

                                                                                   
                                                                                       
                                                                                                              

                                                                                         
                                                           
                                                                                            

                                                                                     
    
 
enum @beta Efl.Ui.Win_Type
{
   [[Defines the types of window that can be created.

     These are hints set on a 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.
   ]]

   unknown = -1, [[Default, unknown type.]]
   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 @Efl.Ui.Win_Type.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
                    menu bar is clicked.
                    This hint exists for completeness' sake, as the EFL way of
                    implementing a menu would not normally use a separate
                    window for its contents.]]
   popup_menu, [[Like @Efl.Ui.Win_Type.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. Not 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 commonly used in
            the EFL.]]
   dnd, [[Internal use.]]
   inlined_image, [[Internal use.]]
   socket_image, [[Internal use.]]
   fake, [[Internal use.]]
   /* Some types have been removed from EO. Skipping to 17. */
   naviframe_basic = 17 [[Used for naviframe style replacement with a back
                          button instead of a close button.
                        ]]
}

enum @beta 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.
   ]]

   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_Mode
{
   [[Defines the type indicator that can be shown.

      @since 1.22
   ]]
   off, [[Request to deactivate the indicator.]]
   bg_opaque, [[The indicator icon is opaque, as is the indicator background.
                The content of window is located at the end of the 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 such as in video mode.
            If user flicks the upper side of window, the indicator is shown temporarily.]]
}

enum @beta Efl.Ui.Win_Modal_Mode
{
   [[Defines the mode of a modal window.]]

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

enum @beta Efl.Ui.Win_Urgent_Mode
{
   [[Defines the mode of a urgent window.]]

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

enum Efl.Ui.Win_Move_Resize_Mode
{
   [[Define the move or resize mode of a window.

     The user can request the display server to start moving or resizing
     the window by combining these modes. However only limited combinations
     are allowed.

     Currently, only the following 9 combinations are permitted.
     More combinations may be added in future:
     1. move,
     2. top,
     3. bottom,
     4. left,
     5. right,
     6. top | left,
     7. top | right,
     8. bottom | left,
     9. bottom | right.

     @since 1.22
   ]]

   move = 1,           [[Start moving window]]
   top = (1 << 1),     [[Start resizing window to the top]]
   bottom = (1 << 2),  [[Start resizing window to the bottom]]
   left = (1 << 3),    [[Start resizing window to the left]]
   right = (1 << 4)    [[Start resizing window to the right]]
}

class Efl.Ui.Win extends Efl.Ui.Widget implements Efl.Canvas.Scene, Efl.Access.Window,
                  Efl.Access.Component, Efl.Access.Widget.Action,
                  Efl.Content, Efl.Input.State, Efl.Input.Interface, Efl.Screen,
                  Efl.Text, Efl.Ui.Widget_Focus_Manager,
                  Efl.Ui.Focus.Manager_Window_Root
   composites     Efl.Config
{
   [[Efl UI window class.

     @since 1.22
   ]]
   methods {
      @property indicator_mode {
           [[In some environments you may have an indicator that
           shows battery status, reception, time etc. This is the indicator.

           Sometimes you don't want this because you provide the same functionality
           inside your app, so this will request that the indicator is disabled in
           such circumstances. The default settings depends on the environment.
           For example, on phones, the default is to enable the indicator.
           The indicator is disabled on devices like televisions however.
         ]]
         set {
         }
         get {
         }
         values {
            type: Efl.Ui.Win_Indicator_Mode; [[The type, one of @Efl.Ui.Win_Indicator_Mode.]]
         }
      }
      @property keyboard_mode @beta {
         [[The keyboard mode of the window.]]
         set {
         }
         get {
         }
         values {
            mode: Efl.Ui.Win_Keyboard_Mode; [[The mode, one of @Efl.Ui.Win_Keyboard_Mode.]]
         }
      }
      @property wm_available_rotations @beta {
         [[Defines which rotations this window supports.

           The window manager will refer to these hints and rotate the window
           accordingly, depending on the device orientation, for instance.
         ]]
         values {
            allow_0: bool; [[Normal orientation.]]
            allow_90: bool; [[Rotated 90 degrees CCW.]]
            allow_180: bool; [[Rotated 180 degrees.]]
            allow_270: bool; [[Rotated 270 degrees CCW (i.e. 90 CW).]]
         }
         set {
         }
         get {
            return: bool; [[Returns $false if available rotations were
                            not specified.]]
         }
      }
      @property wm_available_profiles @beta {
         [[Available profiles on a window.]]
         set {
         }
         get {
         }
         values {
            profiles: const(array<string>); [[A list of profiles.]]
         }
      }
      @property screen_constrain @beta {
         [[Constrain the maximum width and height of a window to the
           width and height of the screen.

           When $constrain is $true, $obj will never resize larger than
           the screen.
         ]]
         set {
         }
         get {
         }
         values {
            constrain: bool; [[$true to restrict the window's maximum size.]]
         }
      }
      @property prop_focus_skip @beta {
         [[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 not to 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 touchscreen,
           never for typing. This may have
           side-effects like making the window non-accessible in
           some cases unless the window is specially handled. Use
           this with care.
         ]]
         set {
         }
         values {
            skip: bool; [[The skip flag state ($true if it is to be skipped).]]
         }
      }
      @property autohide @beta {
         [[Window's autohide 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 this property is set to $true, the window will be automatically
           hidden when this event occurs, after the signal is emitted. If this
           property is $false nothing will happen, beyond the event emission.

           C applications can use this option along with the quit policy
           $ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN which allows exiting EFL'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.
         ]]
         values {
            autohide: bool; [[If $true, the window will automatically hide
                              itself when closed.]]
         }
      }
      @property exit_on_close {
         [[Enable quitting the main loop when this window is closed.

           When set, the window's loop object will exit using the passed exit code if the
           window is closed.

           The @Eina.Value passed should be $EMPTY to unset this state or an int value to be
           used as the exit code.

           Note this is different from @.exit_on_all_windows_closed which exits when ALL
           windows are closed.
         ]]
         values {
            exit_code: const(any_value_ref); [[The exit code to use when exiting]]
         }
      }
      @property icon_object {
         [[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 place them in the window's icon. Note that only objects of
           type @Efl.Canvas.Image or @Efl.Ui.Image are allowed.
         ]]
         set {
            values {
               icon: Efl.Canvas.Object;
                  [[The image object to use for an icon.]]
            }
         }
         get {
            values {
               icon: const(Efl.Canvas.Object);
                  [[The Evas image object to use for an icon.]]
            }
         }
      }
      @property minimized {
         [[The minimized state of a window.]]
         set {
         }
         get {
         }
         values {
            state: bool; [[If $true, the window is minimized.]]
         }
      }
      @property maximized {
         [[The maximized state of a window.]]
         set {
         }
         get {
         }
         values {
            maximized: bool; [[If $true, the window is maximized.]]
         }
      }
      @property fullscreen {
         [[The fullscreen state of a window.]]
         set {
         }
         get {
         }
         values {
            fullscreen: bool; [[If $true, the window is fullscreen.]]
         }
      }
      @property sticky @beta {
         [[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.
         ]]
         set {
         }
         get {
         }
         values {
            sticky: bool; [[If $true, the window's sticky state is enabled.]]
         }
      }
      @property urgent @beta {
         [[The urgent state of a window.]]
         set {
         }
         get {
         }
         values {
            urgent: Efl.Ui.Win_Urgent_Mode;
                [[The mode of a urgent window, one of @Efl.Ui.Win_Urgent_Mode.]]
         }
      }
      @property modal @beta {
         [[The modal state of a window.]]
         set {
         }
         get {
         }
         values {
            modal: Efl.Ui.Win_Modal_Mode; [[The mode of a window, one of @Efl.Ui.Win_Modal_Mode.]]
         }
      }
      @property borderless @beta {
         [[The borderless state of a window.

           This function requests the Window Manager not to draw any
           decoration around the window.
         ]]
         set {
         }
         get {
         }
         values {
            borderless: bool; [[If $true, the window is borderless.]]
         }
      }
      @property win_role @beta {
         /* FIXME: Do we actually need this? There is only support in X. */
         [[The role of the window.

           It is a hint of how the Window Manager should handle it. Unlike
           @.win_type and @.win_name this can be changed at runtime.

           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.
         ]]
         set {
         }
         get {
         }
         values {
            role: string; [[The role to set.]]
         }
      }
      @property win_name {
         [[The window name.

           The meaning of name depends on the underlying windowing system.

           The window name is a construction property that can only be set at
           creation time, before finalize. In C this means inside $efl_add().

           Note: Once set, it cannot be modified afterwards.
         ]]
         set {
         }
         get {
         }
         values {
            name: string; [[Window name]]
         }
      }
      @property win_type @beta {
         [[The type of the window.

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

           The window type is a construction property that can only be set at
           creation time, before finalize. In C this means inside $efl_add().

           Note: Once set, it cannot be modified afterward.

           If the object is not window object, returns @Efl.Ui.Win_Type.unknown.
         ]]
         set {
         }
         get {
         }
         values {
            type: Efl.Ui.Win_Type(Efl.Ui.Win_Type.basic); [[Window type]]
         }
      }
      @property accel_preference @beta {
         [[The hardware acceleration preference for this window.

           This is a constructor function and can only be called before
           @Efl.Object.finalize.

           This property overrides the global EFL configuration option
           "accel_preference" for this single window, and accepts the same
           syntax.

           The $accel string is a freeform C string that indicates
           what kind of acceleration is preferred. Here "acceleration" generally
           refers to rendering and the hardware with which the unit application renders GUIs.
           This may or may not be honored but a best attempt will
           be made. Known strings are as follows:

           "gl", "opengl" - try use OpenGL.
           "3d" - try to use a 3d acceleration unit.
           "hw", "hardware", "accel" - try any acceleration unit (best possible)
           "none" - use no acceleration but software instead (since 1.16)

           Since 1.14, it is also possible to specify some GL properties for the GL
           window surface. This allows applications to use GLView with depth, stencil
           and MSAA buffers with direct rendering. The new accel preference string
           format is thus "{HW Accel}[:depth{value}[:stencil{value}[:msaa{str}$]$]$]".

           Accepted values for depth are for instance "depth", "depth16", "depth24".
           Accepted values for stencil are "stencil", "stencil1", "stencil8".
           For MSAA, only predefined strings are accepted: "msaa", "msaa_low",
           "msaa_mid" and "msaa_high". The selected configuration is not guaranteed
           and is only valid in case of GL acceleration. Only the base acceleration
           string will be saved (e.g. "gl" or "hw").

           Full examples include:

           "gl", - try to use OpenGL
           "hw:depth:stencil", - use HW acceleration with default depth and stencil buffers
           "opengl:depth24:stencil8:msaa_mid" - use OpenGL with 24-bit depth,
                8-bit stencil and a medium number of MSAA samples in the backbuffer.

           Note that this option may be overriden by environment variables
           or the configuration option "accel_preference_override".
         ]]
         values {
            accel: string; [[Acceleration]]
         }
         set {
         }
         get {
         }
      }
      @property alpha {
         [[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, for example a system using 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.
         ]]
         set {
         }
         get {
         }
         values {
            alpha: bool; [[$true if the window alpha channel is enabled,
                           $false otherwise.]]
         }
      }
      @property stack_id @beta {
         [[Get the stack ID string of the window as an opaque string.

           This ID is immutable and can never be modified. It will be
           an opaque string that has no specific defined format or
           content other than being a string (no character with a
           value of 0).

           This string is intended for use as a stack master ID to be
           use by other windows to make this window part of a stack
           of windows to be placed on top of each other as if they are
           a series of dialogs or questions one after the other, allowing
           you to go back through history.]]
         get {
         }
         values {
            id: string; [[An opaque string that has no specific format
                          but identifies a specific unique window on the
                          display.]]
         }
      }
      @property stack_master_id @beta {
         [[The window stack ID to use as the master top-level.

           This sets the ID string to be used as the master top-level
           window as the base of a stack of windows. This must be set
           before the first time the window is shown and should never
           be changed afterwards.]]
         set {
         }
         get {
         }
         values {
            id: string; [[An opaque string that has no specific format,
                          but identifies a specific unique window on the
                          display.]]
         }
      }
      @property stack_base @beta {
         [[The stack base state of this window

           This is a boolean flag that determines if this window will
           become the base of a stack at all. You must enable this
           on a base (the bottom of a window stack) for things to work
           correctly.

           This state should be set before a window is shown for the
           first time and never changed afterwards.]]

         set {}
         get {}
         values {
            base: bool; [[$true if this is a stack base window, $false
                          otherwise.]]
         }
      }
      stack_pop_to @beta {
         [[Pop (delete) all windows in the stack above this window.

           This will try and delete all the windows in the stack that
           are above the window.]]
      }
      @property exit_on_all_windows_closed @static {
         [[Enable quitting the main loop when all windows are closed.

           When set, the main loop will quit with the passed exit code once all windows have been closed.

           The @Eina.Value passed should be $EMPTY to unset this state or an int value to be
           used as the exit code.

           Note this is different from @.exit_on_close which exits when a given window is closed.
         ]]
         values {
            exit_code: const(any_value_ref); [[The exit code to use when exiting.]]
         }
      }
      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 afterwards.
         ]]
      }
      center @beta {
         [[Center a window on the screen.

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

           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 centered afterwards.
         ]]
         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.]]
         }
      }
      move_resize_start {
         [[Start moving or resizing the window.

           The user can request the display server to start moving or resizing
           the window by combining modes from @Efl.Ui.Win_Move_Resize_Mode.
           This API can only be called if none of the following conditions is
           true:

           1. Called in the absence of a pointer down event,
           2. Called more than once before a pointer up event,
           3. Called when the window is already being resized or moved,
           4. Called with an unsupported combination of modes.

           Right usage:
           1. Pointer (mouse or touch) down event,
           2. @.move_resize_start called only once with a supported mode,
           3. Pointer (mouse or touch) up event.

           If a pointer up event occurs after calling the function, it
           automatically ends the window move and resize operation.

           Currently, only the following 9 combinations are allowed, and
           possibly more combinations may be added in the future:
           1. @Efl.Ui.Win_Move_Resize_Mode.move
           2. @Efl.Ui.Win_Move_Resize_Mode.top
           3. @Efl.Ui.Win_Move_Resize_Mode.bottom
           4. @Efl.Ui.Win_Move_Resize_Mode.left
           5. @Efl.Ui.Win_Move_Resize_Mode.right
           6. @Efl.Ui.Win_Move_Resize_Mode.top | @Efl.Ui.Win_Move_Resize_Mode.left
           7. @Efl.Ui.Win_Move_Resize_Mode.top | @Efl.Ui.Win_Move_Resize_Mode.right
           8. @Efl.Ui.Win_Move_Resize_Mode.bottom | @Efl.Ui.Win_Move_Resize_Mode.left
           9. @Efl.Ui.Win_Move_Resize_Mode.bottom | @Efl.Ui.Win_Move_Resize_Mode.right

           In particular move and resize cannot happen simultaneously.

           Note: the result of this API can only guarantee that the request has
           been forwarded to the server, but there is no guarantee that the
           request can be processed by the display server.
         ]]
         return: bool; [[$true if the request was successfully sent to the
                         display server, $false in case of error.]]
         params {
            @in mode: Efl.Ui.Win_Move_Resize_Mode; [[The requested move or
                                                     resize mode.]]
         }
      }
      @property hint_base {
         [[Base size for objects with sizing restrictions.

           This is not a size enforcement in any way, it's just a hint
           that should be used whenever appropriate.

           @.hint_base + N x @.hint_step is what is calculated for object
           sizing restrictions.

           See also @.hint_step.
         ]]
         values {
            sz: Eina.Size2D; [[Base size (hint) in pixels.]]
         }
      }
      @property hint_step {
         [[Step size for objects with sizing restrictions.

           This is not a size enforcement in any way, it's just a hint
           that should be used whenever appropriate.

           Set this to for an object to scale up by steps and not continuously.

           @.hint_base + N x @.hint_step is what is calculated for object
           sizing restrictions.
         ]]
         values {
            sz: Eina.Size2D; [[Step size (hint) in pixels.]]
         }
      }
      /* FIXME: maybe not necessary if gesture supports this */
      pointer_iterate @const @beta {
         [[Returns an iterator over the current known pointer positions.

           This is used to iterate over the current known multi-touch positions,
           including the first finger. Each pointer position is represented by
           an object of type @Efl.Input.Pointer.

           Each finger in a multi touch environment can then be identified
           by the @Efl.Input.Pointer.touch_id property. The order of the pointers
           in this iterator is not defined.

           Note: If the input surface supports hovering input, some pointers
           may not be in a "down" state. To retrieve the list of such pointers,
           set the $hover value to $true. Remember though that most devices
           currently don't support this.
         ]]
         params {
            /* FIXME: missing seat. hover is not useful */
            hover: bool @optional; [[$false by default, $true means to include
                                     fingers that are currently hovering.]]
         }
         return: iterator<const(Efl.Input.Pointer)>; [[Iterator to pointer positions]]
      }
      @property win_rotation @beta {
         [[The rotation of this window

           The value will automatically change when the Window Manager of this window changes its rotation.
           This rotation is automatically applied to all @Efl.Ui.Layout objects.
         ]]
         set {
         }
         get {
         }
         values {
           rotation : int; [[The rotation of the window]]
         }
      }
      @property focus_highlight_enabled {
         [[Whether focus highlight is enabled or not on this window, regardless of the global setting.

           See also @.focus_highlight_style.
           See also @.focus_highlight_animate.
         ]]
         set {
         }
         get {
         }
         values {
            enabled: bool; [[The enabled value for the highlight.]]
         }
      }
      @property focus_highlight_style {
         [[Control the widget focus highlight style.

           If $style is $null, the default will be used.

           See also @.focus_highlight_enabled.
           See also @.focus_highlight_animate.
         ]]
         set {
            /* FIXME: This is async... success here means nothing. */
            return: bool; [[$true on success, $false otherwise.]]
         }
         get {
         }
         values {
            style: string; [[The name of the focus highlight style.]]
         }
      }
      @property focus_highlight_animate {
         [[Whether focus highlight should animate or not.

           See also @.focus_highlight_style.
           See also @.focus_highlight_enabled.
         ]]
         set {
         }
         get {
         }
         values {
            animate: bool; [[The enabled value for the highlight animation.]]
         }
      }
   }
   implements {
      class.constructor;
      Efl.Object.constructor;
      Efl.Object.destructor;
      Efl.Object.provider_find;
      Efl.Object.finalize;
      Efl.Object.debug_name_override;
      Efl.Gfx.Entity.visible { set; }
      Efl.Gfx.Entity.position { set; }
      Efl.Gfx.Entity.size { set; }
      Efl.Gfx.Stack.raise_to_top; [[Places the window at the top of the stack, so
                                   that it's not covered by any other window.]]
      Efl.Gfx.Stack.lower_to_bottom; [[This action is ignored by the Window.]]
      Efl.Ui.Widget.theme_apply;
      Efl.Ui.Focus.Object.focus { get; }
      Efl.Ui.Focus.Object.on_focus_update;
      Efl.Ui.Widget.widget_input_event_handler;
      Efl.Ui.Widget_Focus_Manager.focus_manager_create;
      Efl.Access.Object.state_set { get; }
      Efl.Access.Object.i18n_name { get; }
      Efl.Access.Component.extents { get; }
      Efl.Access.Widget.Action.elm_actions { get; }
      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_in_pixels { get; }
      Efl.Screen.screen_scale_factor { get; }
      Efl.Gfx.Hint.hint_aspect { set; }
      Efl.Gfx.Hint.hint_weight { set; }
      Efl.Gfx.Hint.hint_size_max { set; }
      Efl.Text.text { get; set; }
      Efl.Ui.L10n.l10n_text { get; set; }
      Efl.Ui.I18n.language { get; set; }
      Efl.Canvas.Scene.seat_default { get; }
      Efl.Canvas.Scene.pointer_position { get; }
      Efl.Canvas.Pointer.pointer_inside { get; }
      Efl.Canvas.Scene.image_max_size { get; }
      Efl.Canvas.Scene.group_objects_calculate;
      Efl.Canvas.Scene.group_objects_calculating { get; }
      Efl.Canvas.Scene.objects_at_xy_get;
      Efl.Canvas.Scene.object_top_at_xy_get;
      Efl.Canvas.Scene.objects_in_rectangle_get;
      Efl.Canvas.Scene.object_top_in_rectangle_get;
      Efl.Canvas.Scene.device { get; }
      Efl.Canvas.Scene.seat { get; }
      Efl.Content.content { get; set; }
      Efl.Content.content_unset;
      Efl.Part.part_get;
   }
   constructors {
      .win_name @optional;
      .win_type @optional;
      .accel_preference @optional;
   }
   events {
      delete,request: void; [[Called when the window receives a delete request]]
      withdrawn @beta: void; [[Called when window is withdrawn]]
      minimized: void; [[Called when window is minimized]]
      normal: void; [[Called when window is set to normal state]]
      stick @beta: void; [[Called when window is set as sticky]]
      unstick @beta: void; [[Called when window is no  longer set as sticky]]
      fullscreen,changed: bool; [[Called when window is set to or from fullscreen]]
      maximized,changed: bool; [[Called when window is set to or from maximized]]
      indicator,prop,changed @beta: void; [[Called when indicator is property changed]]
      win_rotation,changed: int; [[Called when window rotation is changed, sends current rotation in degrees]]
      profile,changed @beta: void; [[Called when profile is changed]]
      wm,rotation,changed @beta: void; [[Called when window manager rotation is changed]]
      theme,changed: void; [[Called when theme is changed]]
      elm,action,block_menu @beta: void; [[Called when elementary block menu action occurs]]
      pause: void; [[Called when the window is not going be displayed for some time]]
      resume: void; [[Called before a window is rendered after a pause event]]
   }
}