Typedef for GTypeModule for possible future expansion. This struct contain private data only and should be accessed by the functions below. Creates a new #XfceArrowButton widget. The newly created #XfceArrowButton widget. #GtkArrowType for the arrow button Returns the value of the ::arrow-type property. the #GtkArrowType of @button. a #XfceArrowButton Whether the button is blinking. If the blink timeout is finished and the button is still highlighted, this functions returns %TRUE. %TRUE when @button is blinking. a #XfceArrowButton Sets the arrow type for @button. a #XfceArrowButton a valid #GtkArrowType Make the button blink. a #XfceArrowButton %TRUE when the button should start blinking, %FALSE to stop the blinking. The arrow type of the button. This value also determines the direction of the popup menu. Emitted when the arrow direction of the menu button changes. This value also determines the direction of the popup menu. the new #GtkArrowType of the button Registers a pre-init function in the plugin module. This function is called before gtk_init() and can be used to initialize special libaries. Downside of this that the plugin cannot run internal. Even if you set X-XFCE-Interal=TRUE in the desktop file, the panel will force the plugin to run inside a wrapper (this because the panel called gtk_init() long before it starts to load the plugins). Note that you can only use this once and it only works in combination with the plugins register/define functions added in 4.8. name of the function that points to an #XfcePanelPluginPreInit function. A convenient macro of #G_DEFINE_DYNAMIC_TYPE for panel plugins. Only difference with #G_DEFINE_DYNAMIC_TYPE is that the type name send to g_type_module_register_type() is prefixed with "Xfce". This allows you use use shorted structure names in the code, while the real name of the object is a full "Xfce" name. The _register_type function should be added to the args in #XFCE_PANEL_DEFINE_PLUGIN. The name of the new type, in Camel case. The name of the new type, in lowercase, with words separated by '_'. The GType of the parent type. Defines padding to be used for panel plugin icons (size difference between the button and the icon) Register a panel plugin using a construct function. This is the simplest way to register a panel plugin. The @construct_func is called everytime a plugin is created. name of the function that points to an #XfcePanelPluginFunc function. Same as calling #XFCE_PANEL_DEFINE_PREINIT_FUNC and #XFCE_PANEL_PLUGIN_REGISTER_WITH_CHECK. See those macros for more information. name of the function that points to an #XfcePanelPluginFunc function. name of the function that points to an #XfcePanelPluginPreInit function. name of the function that points to an #XfcePanelPluginCheck function. Register a panel plugin using a construct function. The @check_func will be called before the plugin is created. If this function returns %FALSE, the plugin won't be added to the panel. For proper feedback, you are responsible for showing a dialog why the plugin is not added to the panel. name of the function that points to an #XfcePanelPluginFunc function. name of the function that points to an #XfcePanelPluginCheck function. This struct contain private data only and should be accessed by the functions below. Creates a new empty #XfcePanelImage widget. Use gtk_image_new() instead. a newly created XfcePanelImage widget. Creates a new #XfcePanelImage displaying @pixbuf. #XfcePanelImage will add its own reference rather than adopting yours. You don't need to scale the pixbuf to the correct size, the #XfcePanelImage will take care of that based on the allocation of the widget or the size set with xfce_panel_image_set_size(). Use gtk_image_new_from_pixbuf() instead. a newly created XfcePanelImage widget. a #GdkPixbuf, or %NULL. Creates a new #XfcePanelImage displaying @source. #XfcePanelImage will detect if @source points to an absolute file or it and icon-name. For icon-names it will also look for files in the pixbuf folder or strip the extensions, which makes it suitable for usage with icon keys in .desktop files. Use gtk_image_new() and xfce_panel_set_image_from_source() instead. a newly created XfcePanelImage widget. source of the image. This can be an absolute path or an icon-name or %NULL. Resets the image to be empty. Use gtk_image_clear() instead. an #XfcePanelImage. The size of the image, set by xfce_panel_image_set_size() or -1 if no size is forced and the image is scaled to the allocation size. Use gtk_image_get_pixel_size() or get the size from the #GtkImage storage type instead. icon size in pixels of the image or -1. an #XfcePanelImage. See xfce_panel_image_new_from_pixbuf() for details. Use gtk_image_set_from_pixbuf(). an #XfcePanelImage. a #GdkPixbuf, or %NULL. See xfce_panel_image_new_from_source() for details. Use xfce_panel_set_image_from_source() instead. an #XfcePanelImage. source of the image. This can be an absolute path or an icon-name or %NULL. This will force an image size, instead of looking at the allocation size, see introduction for more details. You can set a @size of -1 to turn this off. Use gtk_image_set_pixel_size() or set the size from the #GtkImage storage type instead. an #XfcePanelImage. a new size in pixels. Use #GtkImage:pixbuf instead. Use #GtkImage:pixel-size instead. Use #GtkImage:storage-type instead. This struct contain private data only and should be accessed by the functions below. Function to be used as #GtkMenuPositionFunc in a call to gtk_menu_popup(). As data argument it needs an #XfcePanelPlugin. The menu is normally positioned relative to @panel_plugin. If you want the menu to be positioned relative to another widget, you can use gtk_menu_attach_to_widget() to explicitly set a 'parent' widget. As a convenience, xfce_panel_plugin_position_menu() calls xfce_panel_plugin_register_menu() for the menu. <example> void myplugin_popup_menu (XfcePanelPlugin *plugin, GtkMenu *menu, GdkEventButton *ev) { gtk_menu_popup (menu, NULL, NULL, xfce_panel_plugin_position_menu, plugin, ev->button, ev->time ); } </example> For a custom widget that will be used as a popup menu, use xfce_panel_plugin_position_widget() instead. See also: gtk_menu_popup(). Use xfce_panel_plugin_popup_menu() instead. a #GtkMenu. return location for the x coordinate. return location for the y coordinate. keep inside the screen (see #GtkMenuPositionFunc) an #XfcePanelPlugin. See #XfcePanelPlugin::about for more information. See #XfcePanelPlugin::configure-plugin for more information. This function is for object orientated plugins and triggered after the init function of the object. When this function is triggered, the plugin information like name, display name, comment and unique id are available. This is also the place where you would call functions like xfce_panel_plugin_menu_show_configure(). You can see this as the replacement of #XfcePanelPluginFunc for object based plugins. Since 4.8. See #XfcePanelPlugin::free-data for more information. See #XfcePanelPlugin::hidden-event for more information. See #XfcePanelPlugin::mode-changed for more information. See #XfcePanelPlugin::nrows-changed for more information. See #XfcePanelPlugin::orientation-changed for more information. See #XfcePanelPlugin::remote-event for more information. See #XfcePanelPlugin::removed for more information. See #XfcePanelPlugin::save for more information. See #XfcePanelPlugin::screen-position-changed for more information. See #XfcePanelPlugin::size-changed for more information. Attach the plugin menu to this widget. Plugin writers should call this for every widget that can receive mouse events. If you forget to call this the plugin will not have a right-click menu and the user won't be able to remove it. an #XfcePanelPlugin. a #GtkWidget that receives mouse events. Determine the #GtkArrowType for a widget that opens a menu. the #GtkArrowType to use. an #XfcePanelPlugin. Whether this plugin blocks the autohide functionality of the panel. Use this when you 'popup' something that is visually attached to the plugin at it will look weird for a user if the panel will hide while he/she is working in the popup. Be sure to use this function as lock/unlock pairs, as a counter is incremented/decremented under the hood. For menus, you can use xfce_panel_plugin_register_menu() which will take care of this. an #XfcePanelPlugin. new blocking state of this plugin. Block configuring the plugin. This will make the "Properties" menu item insensitive. an #XfcePanelPlugin. Grab the focus on @widget. Asks the panel to allow focus on its items and set the focus to the requested widget. an #XfcePanelPlugin. a #GtkWidget inside the plugins that should be focussed. Argument vector passed to the plugin when it was added. Most of the time the return value will be %NULL, but if could for example contain a list of filenames when the user added the plugin with xfce4-panel --add=launcher *.desktop see the code of the launcher plugin how to use this. the argument vector. The vector is owned by the plugin and should not be freed. an #XfcePanelPlugin. This returns the translated comment of the plugin set in the .desktop file of the plugin. the (translated) comment of the plugin. an #XfcePanelPlugin. This returns the translated name of the plugin set in the .desktop file of the plugin. the (translated) display name of the plugin. an #XfcePanelPlugin. Whether the plugin is expanded or not. This set by the plugin using xfce_panel_plugin_set_expand(). %TRUE when the plugin should expand, %FALSE otherwise. an #XfcePanelPlugin. Returns either the icon size defined in the panel's settings or a preferred icon size. an #XfcePanelPlugin, Whether the plugin is locked (not allowing customization). This is emitted through the panel based on the Xfconf locking of the panel window the plugin is embedded on. It is however possible to send a fake signal to the plugin to override this propery, so you should only use this for interface elements and (if you use Xfconf) check the locking yourself before you write any values or query the kiosk mode using the api in libxfce4util. %TRUE if the user is not allowed to modify the plugin, %FALSE is customization is allowed. an #XfcePanelPlugin. The mode of the panel in which the plugin is embedded. the current #XfcePanelPluginMode of the panel. an #XfcePanelPlugin. The internal name of the panel plugin. the name of the panel plugin. an #XfcePanelPlugin. The number of rows of the panel in which the plugin is embedded. the current number of rows of the panel. an #XfcePanelPlugin. The orientation of the panel in which the plugin is embedded. the current #GtkOrientation of the panel. an #XfcePanelPlugin. The property base for this plugin in the xfce4-panel XfconfChannel, this name is something like /plugins/plugin-1. the property base for the xfconf channel userd by a plugin. See also: xfconf_channel_new_with_property_base. XFCE_PANEL_PLUGIN_CHANNEL_NAME and xfce_panel_get_channel_name an #XfcePanelPlugin. The screen position of the panel in which the plugin is embedded. the current #XfceScreenPosition of the panel. an #XfcePanelPlugin. Whether the plugin can shrink if the size on the panel is limited. This is effective with plugins that do not have expand set, but can accept a smaller size when needed. %TRUE when the plugin can shrink, %FALSE otherwise. an #XfcePanelPlugin. The size of the panel in which the plugin is embedded. the current size of the panel. an #XfcePanelPlugin. Whether the plugin is small enough to fit in a single row of a multi-row panel. E.g. if it is a button-like applet. %TRUE when the plugin is small, %FALSE otherwise. an #XfcePanelPlugin. The internal unique id of the plugin. Each plugin in the panel has a unique number that is for example used for the config file name or property base in the xfconf channel. the unique id of the plugin. Since 4.8 an #XfcePanelPlugin. Looks for the plugin resource file. This should be used to get the plugin read location of the config file. You should only use the returned path to read information from, since it might point to a not-writable file (in kiosk mode for example). See also: xfce_panel_plugin_save_location() and xfce_resource_lookup() The path to a config file or %NULL if no file was found. The returned string must be freed using g_free() an #XfcePanelPlugin. Remove all custom menu items added through #xfce_panel_plugin_menu_insert_item from the menu. an #XfcePanelPlugin. Insert a custom menu item to the plugin's right click menu. This item is packed below the first item in the menu, which displays the plugin's name. an #XfcePanelPlugin. a #GtkMenuItem. Show the "About" item in the menu. Clicking on the menu item will emit the "about" signal. an #XfcePanelPlugin. Show the "Properties" item in the menu. Clicking on the menu item will emit the "configure-plugin" signal. an #XfcePanelPlugin. Pops up @menu at @widget if @widget is non-%NULL and if appropriate given the panel position, otherwise pops up @menu at pointer. As a convenience, xfce_panel_plugin_popup_menu() calls xfce_panel_plugin_register_menu() for the @menu. For a custom widget that will be used as a popup menu, use xfce_panel_plugin_popup_window() instead if this widget is a #GtkWindow, or xfce_panel_plugin_position_widget(). See also: gtk_menu_popup_at_widget() and gtk_menu_popup_at_pointer(). an #XfcePanelPlugin. a #GtkMenu. the #GtkWidget to align @menu with or %NULL to pop up @menu at pointer. the #GdkEvent that initiated this request or %NULL if it's the current event. Pops up @window at @widget if @widget is non-%NULL, otherwise pops up @window at @plugin. The user should not have to set any property of @window: this function takes care of setting the necessary properties to make @window appear as a menu widget. This function tries to produce for a #GtkWindow a behavior similar to that produced by xfce_panel_plugin_popup_menu() for a #GtkMenu. In particular, clicking outside the window or pressing Esc should hide it, and the function takes care to lock panel autohide when the window is shown. However, it may be that, especially on Wayland and depending on the compositor used, hiding the window works more or less well. Also, @window positioning at @widget only works on Wayland if the compositor supports the layer-shell protocol, on which many of the panel features also depend. See also: xfce_panel_plugin_popup_menu() and xfce_panel_plugin_position_widget(). an #XfcePanelPlugin. a #GtkWindow. the #GtkWidget to align @window with or %NULL to use @plugin as @widget. Computes the x and y coordinates to position the @menu_widget relative to @attach_widget. If @attach_widget is NULL, the computed position will be relative to @plugin. Note that if the panel is hidden (autohide), you should delay calling this function until the panel is shown, so that it returns the correct coordinates. This function is intended for custom menu widgets and should rarely be used since 4.19.0. For a regular #GtkMenu you should use xfce_panel_plugin_popup_menu() instead, and for a #GtkWindow xfce_panel_plugin_popup_window(), which take care of positioning for you, among other things. See also: xfce_panel_plugin_popup_menu() and xfce_panel_plugin_popup_window(). an #XfcePanelPlugin. a #GtkWidget that will be used as popup menu. a #GtkWidget relative to which the menu should be positioned. return location for the x coordinate. return location for the y coordinate. Register a menu that is about to popup. This will make sure the panel will properly handle its autohide behaviour. You have to call this function every time the menu is opened (e.g. using gtk_menu_popup_at_widget()). If you want to open the menu aligned to the side of the panel (and the plugin), you should use xfce_panel_plugin_popup_menu(). This function will take care of calling xfce_panel_plugin_register_menu() as well. See also: xfce_panel_plugin_popup_menu() and xfce_panel_plugin_block_autohide(). an #XfcePanelPlugin. a #GtkMenu that will be opened Remove this plugin from the panel and remove all its configuration. Plugins should not use this function to implement their own menu item or button to remove theirselfs from the panel, but only in case the there are problems with the plugin in the panel. Always try to inform the user why this occured. an #XfcePanelPlugin. Returns the path that can be used to store configuration information. Don't use this function if you want to read from the config file, but use xfce_panel_plugin_lookup_rc_file() instead. See also: xfce_panel_plugin_lookup_rc_file() and xfce_resource_save_location() The path to a config file or %NULL if no file was found. The returned string must be freed u sing g_free(). an #XfcePanelPlugin. whether to create missing directories. Whether the plugin should expand of not an #XfcePanelPlugin. whether to expand the plugin. Whether the plugin can shrink if the size on the panel is limited. This does not work if the plugin is expanded. an #XfcePanelPlugin. whether the plugin can shrink. Whether the plugin is small enough to fit in a single row of a multi-row panel. E.g. if it is a button-like applet. an #XfcePanelPlugin. whether the plugin is a small button-like applet. Connect a dialog to a plugin. When the @plugin is closed, it will destroy the @window. an #XfcePanelPlugin. a #GtkWindow. Unblock configuring the plugin. This will make the "Properties" menu item sensitive. an #XfcePanelPlugin. The arguments the plugin was started with. If the plugin was not started with any arguments this value is %NULL. Plugin writer can use it to read the arguments array, but xfce_panel_plugin_get_arguments() is recommended. The translated description of the #XfcePanelPlugin. This property is set during plugin construction and can't be set twice. Plugin writer can use it to read the plugin description, but xfce_panel_plugin_get_comment() is recommended. Whether the #XfcePanelPlugin shall request the Gtk dark theme variant (based on the panel setting). The translated display name of the #XfcePanelPlugin. This property is set during plugin construction and can't be set twice. Plugin writer can use it to read the plugin display name, but xfce_panel_plugin_get_display_name() is recommended. Whether the #XfcePanelPlugin expands on the panel. Plugin writers can use it to read or set this property, but xfce_panel_plugin_set_expand() is recommended. The icon-size in pixels of the #XfcePanelPlugin. Plugin writers can use it to read the plugin's icon size, but xfce_panel_plugin_get_icon_size() is recommended. Display mode of the plugin. The internal, unstranslated, name of the #XfcePanelPlugin. Plugin writer can use it to read the plugin name, but xfce_panel_plugin_get_name() is recommended since that returns a const string. Number of rows the plugin is embedded on. The #GtkOrientation of the #XfcePanelPlugin. Plugin writer can use it to read the plugin orientation, but xfce_panel_plugin_get_orientation() is recommended. The #XfceScreenPosition of the #XfcePanelPlugin. Plugin writer can use it to read the plugin's screen position, but xfce_panel_plugin_get_screen_position() is recommended. Whether the #XfcePanelPlugin can shrink when there is no space left on the panel. Plugin writers can use it to read or set this property, but xfce_panel_plugin_set_shrink() is recommended. The size in pixels of the #XfcePanelPlugin. Plugin writer can use it to read the plugin size, but xfce_panel_plugin_get_size() is recommended. Whether the #XfcePanelPlugin is small enough to fit a single row of a multi-row panel. Plugin writers can use it to read or set this property, but xfce_panel_plugin_set_small() is recommended. This signal is emmitted when the About entry in the right-click menu is clicked. Plugin writers can use it to show information about the plugin and display credits of the developers, translators and other contributors. See also: xfce_panel_plugin_menu_show_about(). This signal is emmitted when the Properties entry in the right-click menu is clicked. Plugin writers can use this signal to open a plugin settings dialog. It is their responsibility to block/unblock panel autohide when the dialog is shown/hidden. See also: xfce_panel_plugin_menu_show_configure() and xfce_titled_dialog_new (). This signal is emmitted when the plugin is closing. Plugin writers should use this signal to free any allocated resources. This signal is emmitted when the panel the @plugin is on is transitioning between hidden/visble. new hidden state of the panel. This signal is emmitted whenever the mode of the panel the @plugin is on changes. new #XfcePanelPluginMode of the panel. This signal is emmitted whenever the nrows of the panel the @plugin is on changes. new number of rows of the panel This signal is emmitted whenever the orientation of the panel the @plugin is on changes. Plugins writers can for example use this signal to change the order of widgets in the plugin. new #GtkOrientation of the panel. This signal is emmitted by the user by running xfce4-panel --plugin-event=plugin-name:name:type:value. It can be used for remote communication, like for example to popup a menu. %TRUE to stop signal emission to other plugins, %FALSE to send the signal also to other plugins with the same name. name of the signal. value of the signal. This signal is emmitted when the plugin is permanently removed from the panel configuration by the user. Developers can use this signal to cleanup custom setting locations that for example store passwords. The free-data signal is emitted after this signal! Note that if you use the xfconf channel and base property provided by xfce_panel_plugin_get_property_base() or the rc file location returned by xfce_panel_plugin_save_location(), the panel will take care of removing those settings. This signal is emitted when the plugin should save it's configuration. The signal is always emmitted before the plugin closes (before the "free-data" signal) and also once in 10 minutes or so. See also: xfce_panel_plugin_save_location(). This signal is emmitted whenever the screen position of the panel the @plugin is on changes. Plugins writers can for example use this signal to change the arrow direction of buttons. the new #XfceScreenPosition of the panel. This signal is emmitted whenever the size of the panel the @plugin is on changes. Plugins writers can for example use this signal to update their icon size. If the function returns %FALSE or is not used, the panel will force a square size to the plugin. If you want non-square plugins and you don't need this signal you can use something like this: g_signal_connect (plugin, "size-changed", G_CALLBACK (gtk_true), NULL); the new size of the panel. Callback function that is run before creating a plugin. It should return %FALSE if the plugin is not available for whatever reason. The function can be given as argument to one of the registration macros. %TRUE if the plugin can be started, %FALSE otherwise. the #GdkScreen the panel is running on Class of an #XfcePanelPlugin. The interface can be used to create GObject based plugin. This function is for object orientated plugins and triggered after the init function of the object. When this function is triggered, the plugin information like name, display name, comment and unique id are available. This is also the place where you would call functions like xfce_panel_plugin_menu_show_configure(). You can see this as the replacement of #XfcePanelPluginFunc for object based plugins. Since 4.8. See #XfcePanelPlugin::screen-position-changed for more information. See #XfcePanelPlugin::size-changed for more information. See #XfcePanelPlugin::orientation-changed for more information. See #XfcePanelPlugin::hidden-event for more information. See #XfcePanelPlugin::free-data for more information. See #XfcePanelPlugin::save for more information. See #XfcePanelPlugin::about for more information. See #XfcePanelPlugin::configure-plugin for more information. See #XfcePanelPlugin::removed for more information. See #XfcePanelPlugin::remote-event for more information. See #XfcePanelPlugin::mode-changed for more information. See #XfcePanelPlugin::nrows-changed for more information. Callback function to create the plugin contents. It should be given as the argument to the registration macros. an #XfcePanelPlugin Orientation of the plugin in the panel. Horizontal panel and plugins Vertical rotated panel and plugins Vertical panel with horizontal plugins Callback function that is run in an external plugin before gtk_init(). It should return %FALSE if the plugin is not available for whatever reason. The function can be given as argument to one of the registration macros. The main purpose of this callback is to allow multithreaded plugins to call g_thread_init(). %TRUE on success, %FALSE otherwise. number of arguments to the plugin argument array There are three screen positions for each side of the screen: LEFT/TOP, CENTER and RIGHT/BOTTOM. The XfceScreenPosition is expressed as navigational direction, with possible addition of H or V to denote horizontal and vertical orientation. Additionally there are two floating positions, horizontal and vertical. No position has been set. North West Horizontal North North East Horizontal North West Vertical West South West Vertical North East Vertical East South East Vertical South West Horizontal South South East Horizontal Floating Horizontal Floating Vertical The panel library provides version information, which could be used by plugins to handle new API. This section describes a number of functions that were created to help developers of Xfce Panel plugins. Currently only contains the definition of #XfceScreenPosition. Some commonly used macros in panel plugins. Create regular #GtkButton with a few properties set to be useful in the Xfce panel: Flat (%GTK_RELIEF_NONE), no focus on click and minimal padding. newly created #GtkButton. Create regular #GtkToggleButton with a few properties set to be useful in Xfce panel: Flat (%GTK_RELIEF_NONE), no focus on click and minimal padding. newly created #GtkToggleButton. Function for the name of the Xfconf channel used by the panel. By default this returns "xfce4-panel", but you can override this value with the environment variable XFCE_PANEL_CHANNEL_NAME. name of the Xfconf channel See also: XFCE_PANEL_CHANNEL_NAME, xfce_panel_plugin_xfconf_channel_new and xfce_panel_plugin_get_property_base See xfce_panel_pixbuf_from_source_at_size a GdkPixbuf or %NULL if nothing was found. The value should be released with g_object_unref when no longer used. See also: XfcePanelImage string that contains the location of an icon icon theme or %NULL to use the default icon theme size the icon that should be loaded Try to load a pixbuf from a source string. The source could be an abolute path, an icon name or a filename that points to a file in the pixmaps directory. This function is particularly usefull for loading names from the Icon key of desktop files. The pixbuf is never bigger than @dest_width and @dest_height. If it is when loaded from the disk, the pixbuf is scaled preserving the aspect ratio. a GdkPixbuf or %NULL if nothing was found. The value should be released with g_object_unref when no longer used. See also: XfcePanelImage string that contains the location of an icon icon theme or %NULL to use the default icon theme the maximum returned width of the GdkPixbuf the maximum returned height of the GdkPixbuf Convienient function for opening an XfconfChannel for a plugin. The channel's property base will be propery returned from xfce_panel_plugin_get_property_base(). See also: xfce_panel_plugin_get_property_base, XFCE_PANEL_PLUGIN_CHANNEL_NAME and xfce_panel_get_channel_name An #XfcePanelPlugin. See xfce_panel_pixbuf_from_source_at_size() See also: #XfcePanelImage #GtkImage to be set string that contains the location of an icon icon theme or %NULL to use the default icon theme size the icon that should be loaded desired scale (see gtk_widget_get_scale_factor()) Macros to register panel plugin types and custom types inside panel plugins. Macros to register panel plugins that are compiled as modules. Internal or external is defined by the boolean key <varname>X-XFCE-Internal</varname> in the plugin's .desktop file. Converts the current #XfceScreenPosition into a #GtkOrientation. the #XfceScreenPosition Whether the current #XfceScreenPosition is below of the center of the screen. the #XfceScreenPosition Whether the current #XfceScreenPosition is floating on the screen. the #XfceScreenPosition Whether the current #XfceScreenPosition is horizontal. the #XfceScreenPosition Whether the current #XfceScreenPosition is left of the center of the screen. the #XfceScreenPosition Whether the current #XfceScreenPosition is right of the center of the screen. the #XfceScreenPosition Whether the current #XfceScreenPosition is above of the center of the screen. the #XfceScreenPosition Toggle button with (optional) arrow. The arrow direction will be inverted when the button is toggled. Since 4.8 it is also possible to make the button blink and pack additional widgets in the button, using gtk_container_add(). > #XfcePanelImage has been deprecated since 4.18.1. It was mainly useful with > GTK 2, and is not really adapted to GTK 3. Use #GtkImage instead, and > xfce_panel_set_image_from_source(). The #XfcePanelImage is a widgets suitable for for example panel buttons where the developer does not exacly know the size of the image (due to theming and user setting). The #XfcePanelImage widget automatically scales to the allocated size of the widget. Because of that nature it never requests a size, so this will only work if you pack the image in another widget that will expand it. If you want to force an image size you can use xfce_panel_image_set_size() to set a pixel size, in that case the widget will request an fixed size which makes it usefull for usage in dialogs. The interface plugin developers used to interact with the plugin and the panel.