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, [[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 #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 @Efl.Canvas.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 ]] naviframe_basic [[Used for naviframe style replacement with a back button instead of a close button. @since 1.19 ]] } 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.]] } enum Efl.Ui.Win.Move_Resize_Mode { [[Define the move or resize mode of 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 allowed, and possibly more combinations may be added in the 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.19 ]] legacy: efl_ui_win_move_resize; 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 (Elm.Widget, Efl.Canvas, Elm.Interface.Atspi.Window, Elm.Interface.Atspi_Component, Elm.Interface.Atspi_Widget_Action, Efl.Container, Efl.Input.State, Efl.Input.Interface, Efl.Screen, Efl.Gfx.Size.Hint, Efl.Text, Efl.Config.Global, Efl.Part, Efl.Ui.Focus.Manager ) { [[Efl UI window class]] legacy_prefix: elm_win; eo_prefix: efl_ui_win; event_prefix: efl_ui_win; methods { @property indicator_enabled { [[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. @since 1.18 ]] set { legacy: null; } get { legacy: null; } values { enabled: bool; [[If $true, the indicator is enabled, If $false, the indicator is disabled.]] } } @property indicator_type { [[The indicator type of the window. @since 1.18 ]] set { legacy: null; } get { 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: ptr(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: ptr(int); [[The array of rotation value.]] count: uint; [[The size of the rotations array.]] } return: bool; [[$true on success, $false otherwise]] } } @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; [[$true if window has focus, $false otherwise]] } } @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: Efl.Canvas.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(Efl.Canvas.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 window is 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. ]] set { [[Can only be used at creation time, within \@ref eo_add.]] legacy: null; } get { [[ @since 1.18 ]] } values { name: string @nullable; [[Window name]] } } @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. ]] 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); [[Window type]] } } @property accel_preference { [[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" majorly means to rendering and which hardware unit application renders GUIs with. 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 and use a 3d acceleration unit. "hw", "hardware", "accel" - try any acceleration unit (best possible) "none" - use no acceleration. try use software (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". @since 1.18 ]] values { accel: string; [[Acceleration]] } set { legacy: null; } get { [[This will return the value of "accel_preference" when the window was created.]] } } @property available_profiles { /* FIXME: terminated_array is actually wrong here (the "count" argument * provides the size, not a NULL at the end of it), but we have no way * to represent this in Eolian correctly, it will work fine for C but * will break for other languages; we probably want to re-do this API * completely though, so that it can bind nicely */ set { [[Set the array of available profiles to a window. @since 1.8 ]] values { profiles: terminated_array; [[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: terminated_array; [[The string array of available profiles.]] count: uint; [[The number of members in profiles.]] } return: bool; [[$true on success, $false otherwise]] } } @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.]] } } @property stack_id @beta { get { [[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 desfined format or content other than it 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 eachother as if they are a series of dialogs or questions one after the other and that you may go back through history.]] } values { id: string; [[An opaque string that has no specific format, but identified a specific unique window on the display.]] } } @property stack_master_id @beta { set { [[Set 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 after that point in time ever again.]] } get { [[Get the stack master Id that has been set.]] } values { id: string; [[An opaque string that has no specific format, but identified 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 (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 again after that.]] 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.]] } socket_listen { [[Create a socket to provide the service for Plug widget.]] return: bool; [[$true on success, $false otherwise]] 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; [[$true on success, $false otherwise]] params { @in key: string; [[This string is the keyname to grab.]] @in modifiers: Efl.Input.Modifier; [[A combinaison of modifier keys that must be present to trigger the event. Not supported yet.]] @in not_modifiers: Efl.Input.Modifier; [[A combinaison of modifier keys that must not be present to trigger the event. Not supported yet.]] @in priority: int; [[Not supported yet.]] @in grab_mode: Efl.Ui.Win.Keygrab_Mode; [[Describes how the key should be grabbed, wrt. focus and stacking.]] } legacy: null; } keygrab_unset { [[Unset keygrab value of the window This function unset keygrab value. Ungrab $key of window. ]] return: bool; [[$true on success, $false otherwise]] params { @in key: string; [[This string is the keyname to grab.]] @in modifiers: Efl.Input.Modifier; [[A combinaison of modifier keys that must be present to trigger the event. Not supported yet.]] @in not_modifiers: Efl.Input.Modifier; [[A combinaison of modifier keys that must not be present to trigger the event. Not supported yet.]] } legacy: null; } 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 can not 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. @since 1.19 ]] 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.]] } } } implements { class.constructor; Efl.Object.constructor; Efl.Object.destructor; Efl.Object.finalize; Efl.Object.debug_name_override; Efl.Gfx.visible { set; } Efl.Gfx.position { set; } Efl.Gfx.size { set; } 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.widget_event; Elm.Widget.focus_manager_factory; Elm.Interface.Atspi_Accessible.parent { get; } Elm.Interface.Atspi_Accessible.state_set { get; } Elm.Interface.Atspi_Accessible.name { get; } Elm.Interface.Atspi_Component.extents { get; } Elm.Interface.Atspi_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 { get; } Efl.Gfx.Size.Hint.hint_base { get; set; } Efl.Gfx.Size.Hint.hint_step { get; set; } Efl.Gfx.Size.Hint.hint_aspect { set; } Efl.Gfx.Size.Hint.hint_max { set; } Efl.Text.text { get; set; } Efl.Input.Interface.pointer_xy { get; } Efl.Input.Interface.pointer_inside { get; } Efl.Input.Interface.pointer_iterate; Efl.Canvas.image_max_size { get; } 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; //Efl.Canvas.seats; Efl.Canvas.device { get; } Efl.Canvas.seat { get; } Efl.Container.content { get; set; } Efl.Container.content_unset; Efl.Part.part; Efl.Object.provider_find; } constructors { .name; .type; .accel_preference; } events { delete,request; [[Called when the window got a delete request]] withdrawn; [[Called when window was withdrawn]] iconified; [[Called when window was iconified]] normal; [[Called when window got into normal state]] stick; [[Called when window was set sticky]] unstick; [[Called when window is no longer set sticky]] fullscreen; [[Called when window was set fullscreen]] unfullscreen; [[Called when window is no longer set fullscreen]] maximized; [[Called when window is set maximized]] unmaximized; [[Called when window is no longer set maximized]] ioerr; [[Called on input output error]] /*FIXME Better explanation needed */ indicator,prop,changed; [[Called when indicator property changed]] rotation,changed; [[Called when window rotation changed]] profile,changed; [[Called when profile changed]] wm,rotation,changed; [[Called when window manager rotation changed]] theme,changed; [[Called when theme changed]] elm,action,block_menu; [[Called when elementary block menu action happened]] } }