diff options
Diffstat (limited to 'src/widgets')
27 files changed, 5086 insertions, 0 deletions
diff --git a/src/widgets/control-center/control-button.c b/src/widgets/control-center/control-button.c new file mode 100644 index 0000000..f535a61 --- /dev/null +++ b/src/widgets/control-center/control-button.c @@ -0,0 +1,496 @@ +#include "widgets/control-center/control-button.h" + +// +// FoobarControlButton: +// +// A button in the "controls" section of the control center. This can be a regular button or a toggle button with an +// optional secondary button to toggle a details view. +// + +struct _FoobarControlButton +{ + GtkWidget parent_instance; + gchar* icon_name; + gchar* label; + gboolean can_expand; + gboolean can_toggle; + gboolean is_expanded; + gboolean is_toggled; +}; + +enum +{ + PROP_ICON_NAME = 1, + PROP_LABEL, + PROP_CAN_EXPAND, + PROP_CAN_TOGGLE, + PROP_IS_EXPANDED, + PROP_IS_TOGGLED, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_control_button_class_init ( FoobarControlButtonClass* klass ); +static void foobar_control_button_init ( FoobarControlButton* self ); +static void foobar_control_button_get_property ( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_control_button_set_property ( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_control_button_dispose ( GObject* object ); +static void foobar_control_button_finalize ( GObject* object ); +static void foobar_control_button_handle_primary_clicked( GtkButton* button, + gpointer userdata ); +static void foobar_control_button_handle_expand_clicked ( GtkButton* button, + gpointer userdata ); + +G_DEFINE_FINAL_TYPE( FoobarControlButton, foobar_control_button, GTK_TYPE_WIDGET ) + +// --------------------------------------------------------------------------------------------------------------------- +// Widget Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for control buttons. +// +void foobar_control_button_class_init( FoobarControlButtonClass* klass ) +{ + GtkWidgetClass* widget_klass = GTK_WIDGET_CLASS( klass ); + gtk_widget_class_set_css_name( widget_klass, "control-button" ); + gtk_widget_class_set_layout_manager_type( widget_klass, GTK_TYPE_BOX_LAYOUT ); + + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_control_button_get_property; + object_klass->set_property = foobar_control_button_set_property; + object_klass->dispose = foobar_control_button_dispose; + object_klass->finalize = foobar_control_button_finalize; + + props[PROP_ICON_NAME] = g_param_spec_string( + "icon-name", + "Icon Name", + "Name of the icon to be displayed next to the label.", + NULL, + G_PARAM_READWRITE ); + props[PROP_LABEL] = g_param_spec_string( + "label", + "Label", + "The button's main label.", + NULL, + G_PARAM_READWRITE ); + props[PROP_CAN_EXPAND] = g_param_spec_boolean( + "can-expand", + "Can Expand", + "Indicates whether some details are hidden and can be revealed by a toggle button next to the main action.", + FALSE, + G_PARAM_READWRITE ); + props[PROP_CAN_TOGGLE] = g_param_spec_boolean( + "can-toggle", + "Can Toggle", + "Indicates whether the main button can be toggled.", + FALSE, + G_PARAM_READWRITE ); + props[PROP_IS_EXPANDED] = g_param_spec_boolean( + "is-expanded", + "Is Expanded", + "Indicates whether additional details should be shown.", + FALSE, + G_PARAM_READWRITE ); + props[PROP_IS_TOGGLED] = g_param_spec_boolean( + "is-toggled", + "Is Toggled", + "Indicates whether the main button is currently toggled.", + FALSE, + G_PARAM_READWRITE ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for control buttons. +// +void foobar_control_button_init( FoobarControlButton* self ) +{ + GtkWidget* icon = gtk_image_new( ); + gtk_widget_set_valign( icon, GTK_ALIGN_CENTER ); + g_object_bind_property( + self, + "icon-name", + icon, + "icon-name", + G_BINDING_SYNC_CREATE ); + + GtkWidget* label = gtk_label_new( NULL ); + gtk_widget_set_valign( label, GTK_ALIGN_CENTER ); + gtk_widget_set_hexpand( label, TRUE ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_label_set_xalign( GTK_LABEL( label ), 0 ); + g_object_bind_property( + self, + "label", + label, + "label", + G_BINDING_SYNC_CREATE ); + + GtkWidget* content = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ); + gtk_box_append( GTK_BOX( content ), icon ); + gtk_box_append( GTK_BOX( content ), label ); + + GtkWidget* primary_button = gtk_button_new( ); + gtk_widget_add_css_class( primary_button, "primary" ); + gtk_widget_set_hexpand( primary_button, TRUE ); + gtk_button_set_child( GTK_BUTTON( primary_button ), content ); + g_object_bind_property( + self, + "can-toggle", + primary_button, + "sensitive", + G_BINDING_SYNC_CREATE ); + g_signal_connect( primary_button, "clicked", G_CALLBACK( foobar_control_button_handle_primary_clicked ), self ); + + GtkWidget* expand_button = gtk_button_new_from_icon_name( "fluent-chevron-right-symbolic" ); + gtk_widget_add_css_class( expand_button, "expand" ); + g_object_bind_property( + self, + "can-expand", + expand_button, + "visible", + G_BINDING_SYNC_CREATE ); + g_signal_connect( expand_button, "clicked", G_CALLBACK( foobar_control_button_handle_expand_clicked ), self ); + + GtkLayoutManager* layout = gtk_widget_get_layout_manager( GTK_WIDGET( self ) ); + gtk_orientable_set_orientation( GTK_ORIENTABLE( layout ), GTK_ORIENTATION_HORIZONTAL ); + gtk_widget_insert_before( primary_button, GTK_WIDGET( self ), NULL ); + gtk_widget_insert_before( expand_button, GTK_WIDGET( self ), NULL ); +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_control_button_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarControlButton* self = (FoobarControlButton*)object; + + switch ( prop_id ) + { + case PROP_ICON_NAME: + g_value_set_string( value, foobar_control_button_get_icon_name( self ) ); + break; + case PROP_LABEL: + g_value_set_string( value, foobar_control_button_get_label( self ) ); + break; + case PROP_CAN_EXPAND: + g_value_set_boolean( value, foobar_control_button_can_expand( self ) ); + break; + case PROP_CAN_TOGGLE: + g_value_set_boolean( value, foobar_control_button_can_toggle( self ) ); + break; + case PROP_IS_EXPANDED: + g_value_set_boolean( value, foobar_control_button_is_expanded( self ) ); + break; + case PROP_IS_TOGGLED: + g_value_set_boolean( value, foobar_control_button_is_toggled( self ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_control_button_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarControlButton* self = (FoobarControlButton*)object; + + switch ( prop_id ) + { + case PROP_ICON_NAME: + foobar_control_button_set_icon_name( self, g_value_get_string( value ) ); + break; + case PROP_LABEL: + foobar_control_button_set_label( self, g_value_get_string( value ) ); + break; + case PROP_CAN_EXPAND: + foobar_control_button_set_can_expand( self, g_value_get_boolean( value ) ); + break; + case PROP_CAN_TOGGLE: + foobar_control_button_set_can_toggle( self, g_value_get_boolean( value ) ); + break; + case PROP_IS_EXPANDED: + foobar_control_button_set_expanded( self, g_value_get_boolean( value ) ); + break; + case PROP_IS_TOGGLED: + foobar_control_button_set_toggled( self, g_value_get_boolean( value ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance de-initialization for control buttons. +// +void foobar_control_button_dispose( GObject* object ) +{ + FoobarControlButton* self = (FoobarControlButton*)object; + + GtkWidget* child; + while ( ( child = gtk_widget_get_first_child( GTK_WIDGET( self ) ) ) ) + { + gtk_widget_unparent( child ); + } + + G_OBJECT_CLASS( foobar_control_button_parent_class )->dispose( object ); +} + +// +// Instance cleanup for control buttons. +// +void foobar_control_button_finalize( GObject* object ) +{ + FoobarControlButton* self = (FoobarControlButton*)object; + + g_clear_pointer( &self->icon_name, g_free ); + g_clear_pointer( &self->label, g_free ); + + G_OBJECT_CLASS( foobar_control_button_parent_class )->finalize( object ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new control button instance. +// +GtkWidget* foobar_control_button_new( void ) +{ + return g_object_new( FOOBAR_TYPE_CONTROL_BUTTON, NULL ); +} + +// +// Get the name of the icon to be displayed next to the label. +// +gchar const* foobar_control_button_get_icon_name( FoobarControlButton* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ), NULL ); + return self->icon_name; +} + +// +// Get the button's main label. +// +gchar const* foobar_control_button_get_label( FoobarControlButton* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ), NULL ); + return self->label; +} + +// +// Check whether some details are hidden and can be revealed by a toggle button next to the main action. +// +gboolean foobar_control_button_can_expand( FoobarControlButton* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ), FALSE ); + return self->can_expand; +} + +// +// Check whether the main button can be toggled. +// +gboolean foobar_control_button_can_toggle( FoobarControlButton* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ), FALSE ); + return self->can_toggle; +} + +// +// Check whether additional details should currently be shown. +// +gboolean foobar_control_button_is_expanded( FoobarControlButton* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ), FALSE ); + return self->is_expanded; +} + +// +// Check whether the main button is currently toggled. +// +gboolean foobar_control_button_is_toggled( FoobarControlButton* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ), FALSE ); + return self->is_toggled; +} + +// +// Update the name of the icon to be displayed next to the label. +// +void foobar_control_button_set_icon_name( + FoobarControlButton* self, + gchar const* value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ) ); + + if ( g_strcmp0( self->icon_name, value ) ) + { + g_clear_pointer( &self->icon_name, g_free ); + self->icon_name = g_strdup( value ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_ICON_NAME] ); + } +} + +// +// Update the button's main label. +// +void foobar_control_button_set_label( + FoobarControlButton* self, + gchar const* value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ) ); + + if ( g_strcmp0( self->label, value ) ) + { + g_clear_pointer( &self->label, g_free ); + self->label = g_strdup( value ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_LABEL] ); + } +} + +// +// Update whether some details are hidden and can be revealed by a toggle button next to the main action. +// +void foobar_control_button_set_can_expand( + FoobarControlButton* self, + gboolean value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ) ); + + if ( !value ) { foobar_control_button_set_expanded( self, FALSE ); } + + value = !!value; + if ( self->can_expand != value ) + { + self->can_expand = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CAN_EXPAND] ); + } +} + +// +// Update whether the main button can be toggled. +// +void foobar_control_button_set_can_toggle( + FoobarControlButton* self, + gboolean value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ) ); + + if ( !value ) { foobar_control_button_set_toggled( self, FALSE ); } + + value = !!value; + if ( self->can_toggle != value ) + { + self->can_toggle = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CAN_TOGGLE] ); + } +} + +// +// Update whether additional details are currently shown. +// +void foobar_control_button_set_expanded( + FoobarControlButton* self, + gboolean value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ) ); + + value = value && self->can_expand; + if ( self->is_expanded != value ) + { + self->is_expanded = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_IS_EXPANDED] ); + + if ( self->is_expanded ) + { + gtk_widget_add_css_class( GTK_WIDGET( self ), "expanded" ); + } + else + { + gtk_widget_remove_css_class( GTK_WIDGET( self ), "expanded" ); + } + } +} + +// +// Update whether the main button is currently toggled. +// +void foobar_control_button_set_toggled( + FoobarControlButton* self, + gboolean value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_BUTTON( self ) ); + + value = value && self->can_toggle; + if ( self->is_toggled != value ) + { + self->is_toggled = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_IS_TOGGLED] ); + + if ( self->is_toggled ) + { + gtk_widget_add_css_class( GTK_WIDGET( self ), "toggled" ); + } + else + { + gtk_widget_remove_css_class( GTK_WIDGET( self ), "toggled" ); + } + } +} + +// --------------------------------------------------------------------------------------------------------------------- +// Signal Handlers +// --------------------------------------------------------------------------------------------------------------------- + +// +// Called when the primary button was clicked. +// +// If allowed, this will toggle the button. +// +void foobar_control_button_handle_primary_clicked( GtkButton* button, gpointer userdata ) +{ + (void)button; + FoobarControlButton* self = (FoobarControlButton*)userdata; + + if ( foobar_control_button_can_toggle( self ) ) + { + foobar_control_button_set_toggled( self, !foobar_control_button_is_toggled( self ) ); + } +} + +// +// Called when the expand button was clicked. +// +// If allowed, this will toggle the "expanded" state of the button. +// +void foobar_control_button_handle_expand_clicked( GtkButton* button, gpointer userdata ) +{ + (void)button; + FoobarControlButton* self = (FoobarControlButton*)userdata; + + if ( foobar_control_button_can_expand( self ) ) + { + foobar_control_button_set_expanded( self, !foobar_control_button_is_expanded( self ) ); + } +}
\ No newline at end of file diff --git a/src/widgets/control-center/control-button.h b/src/widgets/control-center/control-button.h new file mode 100644 index 0000000..48dcfb1 --- /dev/null +++ b/src/widgets/control-center/control-button.h @@ -0,0 +1,31 @@ +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_CONTROL_BUTTON foobar_control_button_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarControlButton, foobar_control_button, FOOBAR, CONTROL_BUTTON, GtkWidget ) + +GtkWidget* foobar_control_button_new ( void ); +gchar const* foobar_control_button_get_icon_name ( FoobarControlButton* self ); +gchar const* foobar_control_button_get_label ( FoobarControlButton* self ); +gboolean foobar_control_button_can_expand ( FoobarControlButton* self ); +gboolean foobar_control_button_can_toggle ( FoobarControlButton* self ); +gboolean foobar_control_button_is_expanded ( FoobarControlButton* self ); +gboolean foobar_control_button_is_toggled ( FoobarControlButton* self ); +void foobar_control_button_set_icon_name ( FoobarControlButton* self, + gchar const* value ); +void foobar_control_button_set_label ( FoobarControlButton* self, + gchar const* value ); +void foobar_control_button_set_can_expand( FoobarControlButton* self, + gboolean value ); +void foobar_control_button_set_can_toggle( FoobarControlButton* self, + gboolean value ); +void foobar_control_button_set_expanded ( FoobarControlButton* self, + gboolean value ); +void foobar_control_button_set_toggled ( FoobarControlButton* self, + gboolean value ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/control-center/control-details-item.c b/src/widgets/control-center/control-details-item.c new file mode 100644 index 0000000..f8858d5 --- /dev/null +++ b/src/widgets/control-center/control-details-item.c @@ -0,0 +1,307 @@ +#include "widgets/control-center/control-details-item.h" + +// +// FoobarControlDetailsAccessory: +// +// The accessory shown next to an item in the control center details list (if any). +// + +G_DEFINE_ENUM_TYPE( + FoobarControlDetailsAccessory, + foobar_control_details_accessory, + G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_DETAILS_ACCESSORY_NONE, "none" ), + G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_DETAILS_ACCESSORY_PROGRESS, "progress" ), + G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_DETAILS_ACCESSORY_CHECKED, "checked" ) ) + +// +// FoobarControlDetailsItem: +// +// Standard row layout for items in a FoobarControlDetails list. The rows are made up of a label and an accessory that +// is shown or hidden depending on the item's state. +// + +struct _FoobarControlDetailsItem +{ + GtkWidget parent_instance; + GtkWidget* spinner; + GtkWidget* checkmark; + gchar* label; + FoobarControlDetailsAccessory accessory; +}; + +enum +{ + PROP_LABEL = 1, + PROP_ACCESSORY, + PROP_IS_CHECKED, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_control_details_item_class_init ( FoobarControlDetailsItemClass* klass ); +static void foobar_control_details_item_init ( FoobarControlDetailsItem* self ); +static void foobar_control_details_item_get_property( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_control_details_item_set_property( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_control_details_item_dispose ( GObject* object ); +static void foobar_control_details_item_finalize ( GObject* object ); + +G_DEFINE_FINAL_TYPE( FoobarControlDetailsItem, foobar_control_details_item, GTK_TYPE_WIDGET ) + +// --------------------------------------------------------------------------------------------------------------------- +// Widget Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for control details items. +// +void foobar_control_details_item_class_init( FoobarControlDetailsItemClass* klass ) +{ + GtkWidgetClass* widget_klass = GTK_WIDGET_CLASS( klass ); + gtk_widget_class_set_css_name( widget_klass, "control-details-item" ); + gtk_widget_class_set_layout_manager_type( widget_klass, GTK_TYPE_BOX_LAYOUT ); + + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_control_details_item_get_property; + object_klass->set_property = foobar_control_details_item_set_property; + object_klass->dispose = foobar_control_details_item_dispose; + object_klass->finalize = foobar_control_details_item_finalize; + + props[PROP_LABEL] = g_param_spec_string( + "label", + "Label", + "Label shown for the item.", + NULL, + G_PARAM_READWRITE ); + props[PROP_ACCESSORY] = g_param_spec_enum( + "accessory", + "Accessory", + "Accessory shown for the item.", + FOOBAR_TYPE_CONTROL_DETAILS_ACCESSORY, + 0, + G_PARAM_READWRITE ); + props[PROP_IS_CHECKED] = g_param_spec_boolean( + "is-checked", + "Is Checked", + "Current checked-state for the item.", + FALSE, + G_PARAM_READWRITE ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for control details items. +// +void foobar_control_details_item_init( FoobarControlDetailsItem* self ) +{ + GtkWidget* label = gtk_label_new( NULL ); + gtk_widget_set_hexpand( label, TRUE ); + gtk_widget_set_valign( label, GTK_ALIGN_CENTER ); + gtk_label_set_ellipsize( GTK_LABEL( label ), PANGO_ELLIPSIZE_END ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_label_set_xalign( GTK_LABEL( label ), 0 ); + gtk_label_set_wrap( GTK_LABEL( label ), FALSE ); + g_object_bind_property( + self, + "label", + label, + "label", + G_BINDING_SYNC_CREATE ); + + self->spinner = gtk_spinner_new( ); + gtk_spinner_set_spinning( GTK_SPINNER( self->spinner ), TRUE ); + gtk_widget_add_css_class( self->spinner, "accessory" ); + gtk_widget_set_valign( self->spinner, GTK_ALIGN_CENTER ); + gtk_widget_set_visible( self->spinner, FALSE ); + + self->checkmark = gtk_image_new_from_icon_name( "fluent-checkmark-symbolic" ); + gtk_widget_add_css_class( self->checkmark, "checkmark" ); + gtk_widget_add_css_class( self->checkmark, "accessory" ); + gtk_widget_set_valign( self->checkmark, GTK_ALIGN_CENTER ); + gtk_widget_set_visible( self->checkmark, FALSE ); + + gtk_widget_insert_before( label, GTK_WIDGET( self ), NULL ); + gtk_widget_insert_before( self->spinner, GTK_WIDGET( self ), NULL ); + gtk_widget_insert_before( self->checkmark, GTK_WIDGET( self ), NULL ); +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_control_details_item_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarControlDetailsItem* self = (FoobarControlDetailsItem*)object; + + switch ( prop_id ) + { + case PROP_LABEL: + g_value_set_string( value, foobar_control_details_item_get_label( self ) ); + break; + case PROP_ACCESSORY: + g_value_set_enum( value, foobar_control_details_item_get_accessory( self ) ); + break; + case PROP_IS_CHECKED: + g_value_set_boolean( value, foobar_control_details_item_is_checked( self ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_control_details_item_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarControlDetailsItem* self = (FoobarControlDetailsItem*)object; + + switch ( prop_id ) + { + case PROP_LABEL: + foobar_control_details_item_set_label( self, g_value_get_string( value ) ); + break; + case PROP_ACCESSORY: + foobar_control_details_item_set_accessory( self, g_value_get_enum( value ) ); + break; + case PROP_IS_CHECKED: + foobar_control_details_item_set_checked( self, g_value_get_boolean( value ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance de-initialization for control details items. +// +void foobar_control_details_item_dispose( GObject* object ) +{ + FoobarControlDetailsItem* self = (FoobarControlDetailsItem*)object; + + GtkWidget* child; + while ( ( child = gtk_widget_get_first_child( GTK_WIDGET( self ) ) ) ) + { + gtk_widget_unparent( child ); + } + + G_OBJECT_CLASS( foobar_control_details_item_parent_class )->dispose( object ); +} + +// +// Instance cleanup for control details items. +// +void foobar_control_details_item_finalize( GObject* object ) +{ + FoobarControlDetailsItem* self = (FoobarControlDetailsItem*)object; + + g_clear_pointer( &self->label, g_free ); + + G_OBJECT_CLASS( foobar_control_details_item_parent_class )->finalize( object ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new control details item instance. +// +GtkWidget* foobar_control_details_item_new( void ) +{ + return g_object_new( FOOBAR_TYPE_CONTROL_DETAILS_ITEM, NULL ); +} + +// +// Get the label shown for the item. +// +gchar const* foobar_control_details_item_get_label( FoobarControlDetailsItem* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_DETAILS_ITEM( self ), NULL ); + return self->label; +} + +// +// Get the accessory shown for the item. +// +FoobarControlDetailsAccessory foobar_control_details_item_get_accessory( FoobarControlDetailsItem* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_DETAILS_ITEM( self ), 0 ); + return self->accessory; +} + +// +// Get the current checked-state for the item. +// +gboolean foobar_control_details_item_is_checked( FoobarControlDetailsItem* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_DETAILS_ITEM( self ), FALSE ); + return self->accessory == FOOBAR_CONTROL_DETAILS_ACCESSORY_CHECKED; +} + +// +// Update the label shown for the item. +// +void foobar_control_details_item_set_label( + FoobarControlDetailsItem* self, + gchar const* value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_DETAILS_ITEM( self ) ); + + if ( g_strcmp0( self->label, value ) ) + { + g_clear_pointer( &self->label, g_free ); + self->label = g_strdup( value ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_LABEL] ); + } +} + +// +// Update the current accessory shown for the item. +// +void foobar_control_details_item_set_accessory( + FoobarControlDetailsItem* self, + FoobarControlDetailsAccessory value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_DETAILS_ITEM( self ) ); + + if ( self->accessory != value ) + { + self->accessory = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_ACCESSORY] ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_IS_CHECKED] ); + + gtk_widget_set_visible( self->spinner, self->accessory == FOOBAR_CONTROL_DETAILS_ACCESSORY_PROGRESS ); + gtk_widget_set_visible( self->checkmark, self->accessory == FOOBAR_CONTROL_DETAILS_ACCESSORY_CHECKED ); + } +} + +// +// Update the current checked-state for the item. +// +void foobar_control_details_item_set_checked( + FoobarControlDetailsItem* self, + gboolean value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_DETAILS_ITEM( self ) ); + + FoobarControlDetailsAccessory accessory = value + ? FOOBAR_CONTROL_DETAILS_ACCESSORY_CHECKED + : FOOBAR_CONTROL_DETAILS_ACCESSORY_NONE; + foobar_control_details_item_set_accessory( self, accessory ); +}
\ No newline at end of file diff --git a/src/widgets/control-center/control-details-item.h b/src/widgets/control-center/control-details-item.h new file mode 100644 index 0000000..b9be4a7 --- /dev/null +++ b/src/widgets/control-center/control-details-item.h @@ -0,0 +1,32 @@ +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_CONTROL_DETAILS_ACCESSORY foobar_control_details_accessory_get_type( ) +#define FOOBAR_TYPE_CONTROL_DETAILS_ITEM foobar_control_details_item_get_type( ) + +typedef enum +{ + FOOBAR_CONTROL_DETAILS_ACCESSORY_NONE, + FOOBAR_CONTROL_DETAILS_ACCESSORY_CHECKED, + FOOBAR_CONTROL_DETAILS_ACCESSORY_PROGRESS, +} FoobarControlDetailsAccessory; + +GType foobar_control_details_accessory_get_type( void ); + +G_DECLARE_FINAL_TYPE( FoobarControlDetailsItem, foobar_control_details_item, FOOBAR, CONTROL_DETAILS_ITEM, GtkWidget ) + +GtkWidget* foobar_control_details_item_new ( void ); +gchar const* foobar_control_details_item_get_label ( FoobarControlDetailsItem* self ); +FoobarControlDetailsAccessory foobar_control_details_item_get_accessory( FoobarControlDetailsItem* self ); +gboolean foobar_control_details_item_is_checked ( FoobarControlDetailsItem* self ); +void foobar_control_details_item_set_label ( FoobarControlDetailsItem* self, + gchar const* value ); +void foobar_control_details_item_set_accessory( FoobarControlDetailsItem* self, + FoobarControlDetailsAccessory value ); +void foobar_control_details_item_set_checked ( FoobarControlDetailsItem* self, + gboolean value ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/control-center/control-details.c b/src/widgets/control-center/control-details.c new file mode 100644 index 0000000..4f0d422 --- /dev/null +++ b/src/widgets/control-center/control-details.c @@ -0,0 +1,289 @@ +#include "widgets/control-center/control-details.h" + +// +// FoobarControlDetails: +// +// A revealer for details in the "controls" section of the control center. This widget is usually used to embed a list +// view. It takes care of scrolling by embedding the child in a GtkScrolledWindow. +// + +struct _FoobarControlDetails +{ + GtkWidget parent_instance; + GtkWidget* child; + gboolean is_expanded; + gint inset_top; +}; + +enum +{ + PROP_CHILD = 1, + PROP_IS_EXPANDED, + PROP_INSET_TOP, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_control_details_class_init ( FoobarControlDetailsClass* klass ); +static void foobar_control_details_init ( FoobarControlDetails* self ); +static void foobar_control_details_get_property( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_control_details_set_property( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_control_details_dispose ( GObject* object ); + +G_DEFINE_FINAL_TYPE( FoobarControlDetails, foobar_control_details, GTK_TYPE_WIDGET ) + +// --------------------------------------------------------------------------------------------------------------------- +// Widget Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for control details. +// +void foobar_control_details_class_init( FoobarControlDetailsClass* klass ) +{ + GtkWidgetClass* widget_klass = GTK_WIDGET_CLASS( klass ); + gtk_widget_class_set_css_name( widget_klass, "control-details" ); + gtk_widget_class_set_layout_manager_type( widget_klass, GTK_TYPE_BIN_LAYOUT ); + + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_control_details_get_property; + object_klass->set_property = foobar_control_details_set_property; + object_klass->dispose = foobar_control_details_dispose; + + props[PROP_CHILD] = g_param_spec_object( + "child", + "Child", + "Child widget for the details revealer.", + GTK_TYPE_WIDGET, + G_PARAM_READWRITE ); + props[PROP_IS_EXPANDED] = g_param_spec_boolean( + "is-expanded", + "Is Expanded", + "Current state of the details revealer.", + FALSE, + G_PARAM_READWRITE ); + props[PROP_INSET_TOP] = g_param_spec_int( + "inset-top", + "Inset Top", + "Inset from the top edge (only visible when expanded).", + 0, + INT_MAX, + 0, + G_PARAM_READWRITE ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for control details. +// +void foobar_control_details_init( FoobarControlDetails* self ) +{ + GtkWidget* scrolled_window = gtk_scrolled_window_new( ); + gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolled_window ), GTK_POLICY_NEVER, GTK_POLICY_EXTERNAL ); + gtk_scrolled_window_set_propagate_natural_height( GTK_SCROLLED_WINDOW( scrolled_window ), TRUE ); + g_object_bind_property( + self, + "child", + scrolled_window, + "child", + G_BINDING_SYNC_CREATE ); + g_object_bind_property( + self, + "inset-top", + scrolled_window, + "margin-top", + G_BINDING_SYNC_CREATE ); + + GtkWidget* revealer = gtk_revealer_new( ); + gtk_revealer_set_transition_type( GTK_REVEALER( revealer ), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN ); + gtk_revealer_set_transition_duration( GTK_REVEALER( revealer ), 100 ); + gtk_revealer_set_child( GTK_REVEALER( revealer ), scrolled_window ); + g_object_bind_property( + self, + "is-expanded", + revealer, + "reveal-child", + G_BINDING_SYNC_CREATE ); + + gtk_widget_set_parent( revealer, GTK_WIDGET( self ) ); +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_control_details_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarControlDetails* self = (FoobarControlDetails*)object; + + switch ( prop_id ) + { + case PROP_CHILD: + g_value_set_object( value, foobar_control_details_get_child( self ) ); + break; + case PROP_IS_EXPANDED: + g_value_set_boolean( value, foobar_control_details_is_expanded( self ) ); + break; + case PROP_INSET_TOP: + g_value_set_int( value, foobar_control_details_get_inset_top( self ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_control_details_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarControlDetails* self = (FoobarControlDetails*)object; + + switch ( prop_id ) + { + case PROP_CHILD: + foobar_control_details_set_child( self, g_value_get_object( value ) ); + break; + case PROP_IS_EXPANDED: + foobar_control_details_set_expanded( self, g_value_get_boolean( value ) ); + break; + case PROP_INSET_TOP: + foobar_control_details_set_inset_top( self, g_value_get_int( value ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance de-initialization for control details. +// +void foobar_control_details_dispose( GObject* object ) +{ + FoobarControlDetails* self = (FoobarControlDetails*)object; + + GtkWidget* child; + while ( ( child = gtk_widget_get_first_child( GTK_WIDGET( self ) ) ) ) + { + gtk_widget_unparent( child ); + } + + g_clear_object( &self->child ); + + G_OBJECT_CLASS( foobar_control_details_parent_class )->dispose( object ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new control details instance. +// +GtkWidget* foobar_control_details_new( void ) +{ + return g_object_new( FOOBAR_TYPE_CONTROL_DETAILS, NULL ); +} + +// +// Get the child widget for the details revealer. +// +GtkWidget* foobar_control_details_get_child( FoobarControlDetails* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_DETAILS( self ), NULL ); + return self->child; +} + +// +// Get the current state of the details revealer. +// +gboolean foobar_control_details_is_expanded( FoobarControlDetails* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_DETAILS( self ), FALSE ); + return self->is_expanded; +} + +// +// Get the inset from the top edge (only visible when expanded). +// +gint foobar_control_details_get_inset_top( FoobarControlDetails* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_DETAILS( self ), FALSE ); + return self->inset_top; +} + +// +// Update the child widget for the details revealer. +// +void foobar_control_details_set_child( + FoobarControlDetails* self, + GtkWidget* value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_DETAILS( self ) ); + + if ( self->child != value ) + { + g_clear_object( &self->child ); + if ( value ) { self->child = g_object_ref( value ); } + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CHILD] ); + } +} + +// +// Update the current state of the details revealer. +// +void foobar_control_details_set_expanded( + FoobarControlDetails* self, + gboolean value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_DETAILS( self ) ); + + value = !!value; + if ( self->is_expanded != value ) + { + self->is_expanded = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_IS_EXPANDED] ); + + if ( self->is_expanded ) + { + gtk_widget_add_css_class( GTK_WIDGET( self ), "expanded" ); + } + else + { + gtk_widget_remove_css_class( GTK_WIDGET( self ), "expanded" ); + } + } +} + +// +// Update the inset from the top edge (only visible when expanded). +// +void foobar_control_details_set_inset_top( + FoobarControlDetails* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_DETAILS( self ) ); + + value = MAX( value, 0 ); + if ( self->inset_top != value ) + { + self->inset_top = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_INSET_TOP] ); + } +}
\ No newline at end of file diff --git a/src/widgets/control-center/control-details.h b/src/widgets/control-center/control-details.h new file mode 100644 index 0000000..71df683 --- /dev/null +++ b/src/widgets/control-center/control-details.h @@ -0,0 +1,22 @@ +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_CONTROL_DETAILS foobar_control_details_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarControlDetails, foobar_control_details, FOOBAR, CONTROL_DETAILS, GtkWidget ) + +GtkWidget* foobar_control_details_new ( void ); +GtkWidget* foobar_control_details_get_child ( FoobarControlDetails* self ); +gboolean foobar_control_details_is_expanded ( FoobarControlDetails* self ); +gint foobar_control_details_get_inset_top( FoobarControlDetails* self ); +void foobar_control_details_set_child ( FoobarControlDetails* self, + GtkWidget* value ); +void foobar_control_details_set_expanded ( FoobarControlDetails* self, + gboolean value ); +void foobar_control_details_set_inset_top( FoobarControlDetails* self, + gint value ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/control-center/control-slider.c b/src/widgets/control-center/control-slider.c new file mode 100644 index 0000000..d98dc9e --- /dev/null +++ b/src/widgets/control-center/control-slider.c @@ -0,0 +1,428 @@ +#include "widgets/control-center/control-slider.h" + +// +// FoobarControlSlider: +// +// A slider in the "controls" section of the control center with a title and icon, as well as an optional secondary +// button to toggle a details view. +// + +struct _FoobarControlSlider +{ + GtkWidget parent_instance; + gchar* icon_name; + gchar* label; + gboolean can_expand; + gboolean is_expanded; + gint percentage; +}; + +enum +{ + PROP_ICON_NAME = 1, + PROP_LABEL, + PROP_CAN_EXPAND, + PROP_IS_EXPANDED, + PROP_PERCENTAGE, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_control_slider_class_init ( FoobarControlSliderClass* klass ); +static void foobar_control_slider_init ( FoobarControlSlider* self ); +static void foobar_control_slider_get_property ( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_control_slider_set_property ( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_control_slider_dispose ( GObject* object ); +static void foobar_control_slider_finalize ( GObject* object ); +static void foobar_control_slider_handle_expand_clicked( GtkButton* button, + gpointer userdata ); + +G_DEFINE_FINAL_TYPE( FoobarControlSlider, foobar_control_slider, GTK_TYPE_WIDGET ) + +// --------------------------------------------------------------------------------------------------------------------- +// Widget Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for control sliders. +// +void foobar_control_slider_class_init( FoobarControlSliderClass* klass ) +{ + GtkWidgetClass* widget_klass = GTK_WIDGET_CLASS( klass ); + gtk_widget_class_set_css_name( widget_klass, "control-slider" ); + gtk_widget_class_set_layout_manager_type( widget_klass, GTK_TYPE_BOX_LAYOUT ); + + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_control_slider_get_property; + object_klass->set_property = foobar_control_slider_set_property; + object_klass->dispose = foobar_control_slider_dispose; + object_klass->finalize = foobar_control_slider_finalize; + + props[PROP_ICON_NAME] = g_param_spec_string( + "icon-name", + "Icon Name", + "Name of the icon to be displayed next to the label.", + NULL, + G_PARAM_READWRITE ); + props[PROP_LABEL] = g_param_spec_string( + "label", + "Label", + "The slider's main label.", + NULL, + G_PARAM_READWRITE ); + props[PROP_CAN_EXPAND] = g_param_spec_boolean( + "can-expand", + "Can Expand", + "Indicates whether some details are hidden and can be revealed by a toggle button next to the slider.", + FALSE, + G_PARAM_READWRITE ); + props[PROP_IS_EXPANDED] = g_param_spec_boolean( + "is-expanded", + "Is Expanded", + "Indicates whether additional details should be shown.", + FALSE, + G_PARAM_READWRITE ); + props[PROP_PERCENTAGE] = g_param_spec_int( + "percentage", + "Percentage", + "Value shown by the slider.", + 0, + 100, + 0, + G_PARAM_READWRITE ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for control sliders. +// +void foobar_control_slider_init( FoobarControlSlider* self ) +{ + GtkWidget* icon = gtk_image_new( ); + gtk_widget_set_valign( icon, GTK_ALIGN_CENTER ); + g_object_bind_property( + self, + "icon-name", + icon, + "icon-name", + G_BINDING_SYNC_CREATE ); + + GtkWidget* label = gtk_label_new( NULL ); + gtk_widget_set_valign( label, GTK_ALIGN_CENTER ); + gtk_widget_set_hexpand( label, TRUE ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_label_set_xalign( GTK_LABEL( label ), 0 ); + g_object_bind_property( + self, + "label", + label, + "label", + G_BINDING_SYNC_CREATE ); + + GtkWidget* header = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ); + gtk_box_append( GTK_BOX( header ), icon ); + gtk_box_append( GTK_BOX( header ), label ); + + GtkWidget* scale = gtk_scale_new_with_range( GTK_ORIENTATION_HORIZONTAL, 0, 100, 2 ); + g_object_bind_property( + self, + "percentage", + gtk_range_get_adjustment( GTK_RANGE( scale ) ), + "value", + G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL ); + + GtkWidget* primary_content = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 ); + gtk_widget_add_css_class( primary_content, "primary" ); + gtk_box_append( GTK_BOX( primary_content ), header ); + gtk_box_append( GTK_BOX( primary_content ), scale ); + + GtkWidget* expand_button = gtk_button_new_from_icon_name( "fluent-chevron-right-symbolic" ); + gtk_widget_add_css_class( expand_button, "expand" ); + g_object_bind_property( + self, + "can-expand", + expand_button, + "visible", + G_BINDING_SYNC_CREATE ); + g_signal_connect( expand_button, "clicked", G_CALLBACK( foobar_control_slider_handle_expand_clicked ), self ); + + GtkLayoutManager* layout = gtk_widget_get_layout_manager( GTK_WIDGET( self ) ); + gtk_orientable_set_orientation( GTK_ORIENTABLE( layout ), GTK_ORIENTATION_HORIZONTAL ); + gtk_widget_insert_before( primary_content, GTK_WIDGET( self ), NULL ); + gtk_widget_insert_before( expand_button, GTK_WIDGET( self ), NULL ); +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_control_slider_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarControlSlider* self = (FoobarControlSlider*)object; + + switch ( prop_id ) + { + case PROP_ICON_NAME: + g_value_set_string( value, foobar_control_slider_get_icon_name( self ) ); + break; + case PROP_LABEL: + g_value_set_string( value, foobar_control_slider_get_label( self ) ); + break; + case PROP_CAN_EXPAND: + g_value_set_boolean( value, foobar_control_slider_can_expand( self ) ); + break; + case PROP_IS_EXPANDED: + g_value_set_boolean( value, foobar_control_slider_is_expanded( self ) ); + break; + case PROP_PERCENTAGE: + g_value_set_int( value, foobar_control_slider_get_percentage( self ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_control_slider_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarControlSlider* self = (FoobarControlSlider*)object; + + switch ( prop_id ) + { + case PROP_ICON_NAME: + foobar_control_slider_set_icon_name( self, g_value_get_string( value ) ); + break; + case PROP_LABEL: + foobar_control_slider_set_label( self, g_value_get_string( value ) ); + break; + case PROP_CAN_EXPAND: + foobar_control_slider_set_can_expand( self, g_value_get_boolean( value ) ); + break; + case PROP_IS_EXPANDED: + foobar_control_slider_set_expanded( self, g_value_get_boolean( value ) ); + break; + case PROP_PERCENTAGE: + foobar_control_slider_set_percentage( self, g_value_get_int( value ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance de-initialization for control sliders. +// +void foobar_control_slider_dispose( GObject* object ) +{ + FoobarControlSlider* self = (FoobarControlSlider*)object; + + GtkWidget* child; + while ( ( child = gtk_widget_get_first_child( GTK_WIDGET( self ) ) ) ) + { + gtk_widget_unparent( child ); + } + + G_OBJECT_CLASS( foobar_control_slider_parent_class )->dispose( object ); +} + +// +// Instance cleanup for control sliders. +// +void foobar_control_slider_finalize( GObject* object ) +{ + FoobarControlSlider* self = (FoobarControlSlider*)object; + + g_clear_pointer( &self->icon_name, g_free ); + g_clear_pointer( &self->label, g_free ); + + G_OBJECT_CLASS( foobar_control_slider_parent_class )->finalize( object ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new control slider instance. +// +GtkWidget* foobar_control_slider_new( void ) +{ + return g_object_new( FOOBAR_TYPE_CONTROL_SLIDER, NULL ); +} + +// +// Get the name of the icon to be displayed next to the label. +// +gchar const* foobar_control_slider_get_icon_name( FoobarControlSlider* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ), NULL ); + return self->icon_name; +} + +// +// Get the slider's main label. +// +gchar const* foobar_control_slider_get_label( FoobarControlSlider* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ), NULL ); + return self->label; +} + +// +// Check whether some details are hidden and can be revealed by a toggle button next to the slider. +// +gboolean foobar_control_slider_can_expand( FoobarControlSlider* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ), FALSE ); + return self->can_expand; +} + +// +// Check whether additional details should currently be shown. +// +gboolean foobar_control_slider_is_expanded( FoobarControlSlider* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ), FALSE ); + return self->is_expanded; +} + +// +// Get the value shown by the slider. +// +gint foobar_control_slider_get_percentage( FoobarControlSlider* self ) +{ + g_return_val_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ), FALSE ); + return self->percentage; +} + +// +// Update the name of the icon to be displayed next to the label. +// +void foobar_control_slider_set_icon_name( + FoobarControlSlider* self, + gchar const* value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ) ); + + if ( g_strcmp0( self->icon_name, value ) ) + { + g_clear_pointer( &self->icon_name, g_free ); + self->icon_name = g_strdup( value ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_ICON_NAME] ); + } +} + +// +// Update the slider's main label. +// +void foobar_control_slider_set_label( + FoobarControlSlider* self, + gchar const* value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ) ); + + if ( g_strcmp0( self->label, value ) ) + { + g_clear_pointer( &self->label, g_free ); + self->label = g_strdup( value ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_LABEL] ); + } +} + +// +// Update whether some details are hidden and can be revealed by a toggle button next to the slider. +// +void foobar_control_slider_set_can_expand( + FoobarControlSlider* self, + gboolean value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ) ); + + if ( !value ) { foobar_control_slider_set_expanded( self, FALSE ); } + + value = !!value; + if ( self->can_expand != value ) + { + self->can_expand = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CAN_EXPAND] ); + } +} + +// +// Update whether additional details are currently shown. +// +void foobar_control_slider_set_expanded( + FoobarControlSlider* self, + gboolean value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ) ); + + value = value && self->can_expand; + if ( self->is_expanded != value ) + { + self->is_expanded = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_IS_EXPANDED] ); + + if ( self->is_expanded ) + { + gtk_widget_add_css_class( GTK_WIDGET( self ), "expanded" ); + } + else + { + gtk_widget_remove_css_class( GTK_WIDGET( self ), "expanded" ); + } + } +} + +// +// Update the value shown by the slider. +// +void foobar_control_slider_set_percentage( FoobarControlSlider* self, gint value ) +{ + g_return_if_fail( FOOBAR_IS_CONTROL_SLIDER( self ) ); + + value = CLAMP( value, 0, 100 ); + if ( self->percentage != value ) + { + self->percentage = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_PERCENTAGE] ); + } +} + +// --------------------------------------------------------------------------------------------------------------------- +// Signal Handlers +// --------------------------------------------------------------------------------------------------------------------- + +// +// Called when the expand button was clicked. +// +// If allowed, this will toggle the "expanded" state of the slider. +// +void foobar_control_slider_handle_expand_clicked( GtkButton* button, gpointer userdata ) +{ + (void)button; + FoobarControlSlider* self = (FoobarControlSlider*)userdata; + + if ( foobar_control_slider_can_expand( self ) ) + { + foobar_control_slider_set_expanded( self, !foobar_control_slider_is_expanded( self ) ); + } +}
\ No newline at end of file diff --git a/src/widgets/control-center/control-slider.h b/src/widgets/control-center/control-slider.h new file mode 100644 index 0000000..e7dfac0 --- /dev/null +++ b/src/widgets/control-center/control-slider.h @@ -0,0 +1,28 @@ +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_CONTROL_SLIDER foobar_control_slider_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarControlSlider, foobar_control_slider, FOOBAR, CONTROL_SLIDER, GtkWidget ) + +GtkWidget* foobar_control_slider_new ( void ); +gchar const* foobar_control_slider_get_icon_name ( FoobarControlSlider* self ); +gchar const* foobar_control_slider_get_label ( FoobarControlSlider* self ); +gboolean foobar_control_slider_can_expand ( FoobarControlSlider* self ); +gboolean foobar_control_slider_is_expanded ( FoobarControlSlider* self ); +gint foobar_control_slider_get_percentage( FoobarControlSlider* self ); +void foobar_control_slider_set_icon_name ( FoobarControlSlider* self, + gchar const* value ); +void foobar_control_slider_set_label ( FoobarControlSlider* self, + gchar const* value ); +void foobar_control_slider_set_can_expand( FoobarControlSlider* self, + gboolean value ); +void foobar_control_slider_set_expanded ( FoobarControlSlider* self, + gboolean value ); +void foobar_control_slider_set_percentage( FoobarControlSlider* self, + gint value ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/control-center/meson.build b/src/widgets/control-center/meson.build new file mode 100644 index 0000000..5b1252d --- /dev/null +++ b/src/widgets/control-center/meson.build @@ -0,0 +1,6 @@ +foobar_sources += files( + 'control-button.c', + 'control-slider.c', + 'control-details.c', + 'control-details-item.c', +)
\ No newline at end of file diff --git a/src/widgets/inset-container.c b/src/widgets/inset-container.c new file mode 100644 index 0000000..9b9b132 --- /dev/null +++ b/src/widgets/inset-container.c @@ -0,0 +1,363 @@ +#include "widgets/inset-container.h" + +// +// FoobarInsetContainer: +// +// A custom widget which renders a child with an inset/padding. +// +// Notably, it also supports negative inset values which is useful in order to provide uniform spacing between widgets. +// + +struct _FoobarInsetContainer +{ + GtkWidget parent_instance; + GtkWidget* child; + gint inset_horizontal; + gint inset_vertical; +}; + +enum +{ + PROP_CHILD = 1, + PROP_INSET_HORIZONTAL, + PROP_INSET_VERTICAL, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_inset_container_class_init ( FoobarInsetContainerClass* klass ); +static void foobar_inset_container_init ( FoobarInsetContainer* self ); +static void foobar_inset_container_get_property ( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_inset_container_set_property ( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_inset_container_dispose ( GObject* object ); +static GtkSizeRequestMode foobar_inset_container_get_request_mode( GtkWidget* widget ); +static void foobar_inset_container_measure ( GtkWidget* widget, + GtkOrientation orientation, + int for_size, + int* minimum, + int* natural, + int* minimum_baseline, + int* natural_baseline ); +static void foobar_inset_container_size_allocate ( GtkWidget* widget, + int width, + int height, + int baseline ); + +G_DEFINE_FINAL_TYPE( FoobarInsetContainer, foobar_inset_container, GTK_TYPE_WIDGET ) + +// --------------------------------------------------------------------------------------------------------------------- +// Widget Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for inset containers. +// +void foobar_inset_container_class_init( FoobarInsetContainerClass* klass ) +{ + GtkWidgetClass* widget_klass = GTK_WIDGET_CLASS( klass ); + widget_klass->get_request_mode = foobar_inset_container_get_request_mode; + widget_klass->measure = foobar_inset_container_measure; + widget_klass->size_allocate = foobar_inset_container_size_allocate; + gtk_widget_class_set_css_name( widget_klass, "inset-container" ); + + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_inset_container_get_property; + object_klass->set_property = foobar_inset_container_set_property; + object_klass->dispose = foobar_inset_container_dispose; + + props[PROP_CHILD] = g_param_spec_object( + "child", + "Child", + "Child widget for the panel item.", + GTK_TYPE_WIDGET, + G_PARAM_READWRITE ); + props[PROP_INSET_HORIZONTAL] = g_param_spec_int( + "inset-horizontal", + "Inset Horizontal", + "The horizontal offset (may be negative).", + INT_MIN, + INT_MAX, + 0, + G_PARAM_READWRITE ); + props[PROP_INSET_VERTICAL] = g_param_spec_int( + "inset-vertical", + "Inset Vertical", + "The vertical offset (may be negative).", + INT_MIN, + INT_MAX, + 0, + G_PARAM_READWRITE ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for inset containers. +// +void foobar_inset_container_init( FoobarInsetContainer* self ) +{ + (void)self; +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_inset_container_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarInsetContainer* self = (FoobarInsetContainer*)object; + + switch ( prop_id ) + { + case PROP_CHILD: + g_value_set_object( value, foobar_inset_container_get_child( self ) ); + break; + case PROP_INSET_HORIZONTAL: + g_value_set_int( value, foobar_inset_container_get_inset_horizontal( self ) ); + break; + case PROP_INSET_VERTICAL: + g_value_set_int( value, foobar_inset_container_get_inset_vertical( self ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_inset_container_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarInsetContainer* self = (FoobarInsetContainer*)object; + + switch ( prop_id ) + { + case PROP_CHILD: + foobar_inset_container_set_child( self, g_value_get_object( value ) ); + break; + case PROP_INSET_HORIZONTAL: + foobar_inset_container_set_inset_horizontal( self, g_value_get_int( value ) ); + break; + case PROP_INSET_VERTICAL: + foobar_inset_container_set_inset_vertical( self, g_value_get_int( value ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance de-initialization for inset containers. +// +void foobar_inset_container_dispose( GObject* object ) +{ + FoobarInsetContainer* self = (FoobarInsetContainer*)object; + + g_clear_pointer( &self->child, gtk_widget_unparent ); + + G_OBJECT_CLASS( foobar_inset_container_parent_class )->dispose( object ); +} + +// +// Determine the size request mode used to measure the widget. +// +// This implementation just forwards the request mode from the child widget. +// +GtkSizeRequestMode foobar_inset_container_get_request_mode( GtkWidget* widget ) +{ + FoobarInsetContainer* self = (FoobarInsetContainer*)widget; + if ( !self->child ) { return GTK_SIZE_REQUEST_CONSTANT_SIZE; } + + return gtk_widget_get_request_mode( self->child ); +} + +// +// Compute the requested size of the widget. +// +// This implementation uses the size requested by the child widget and then adds the inset to it. +// +void foobar_inset_container_measure( + GtkWidget* widget, + GtkOrientation orientation, + int for_size, + int* minimum, + int* natural, + int* minimum_baseline, + int* natural_baseline ) +{ + FoobarInsetContainer* self = (FoobarInsetContainer*)widget; + if ( !self->child ) + { + *minimum = 0; + *natural = 0; + *minimum_baseline = 0; + *natural_baseline = 0; + return; + } + + // Get the inset for the given orientation and the other one. + + gint inset; + gint other_inset; + switch ( orientation ) + { + case GTK_ORIENTATION_HORIZONTAL: + inset = self->inset_horizontal; + other_inset = self->inset_vertical; + break; + case GTK_ORIENTATION_VERTICAL: + inset = self->inset_vertical; + other_inset = self->inset_horizontal; + break; + default: + g_warn_if_reached( ); + return; + } + + // Compute the new size, taking into consideration that the inset might have already been added to measure the other + // side and needs to be subtracted before passing it to the child widget's measure function. + + for_size = MAX( 0, for_size - ( 2 * other_inset ) ); + gtk_widget_measure( self->child, orientation, for_size, minimum, natural, minimum_baseline, natural_baseline ); + *minimum = MAX( 0, *minimum + ( 2 * inset ) ); + *natural = MAX( 0, *natural + ( 2 * inset ) ); + if ( orientation == GTK_ORIENTATION_VERTICAL ) + { + *minimum_baseline = MAX( 0, *minimum_baseline + inset ); + *natural_baseline = MAX( 0, *natural_baseline + inset ); + } +} + +// +// Arrange the child widget. +// +void foobar_inset_container_size_allocate( + GtkWidget* widget, + int width, + int height, + int baseline ) +{ + FoobarInsetContainer* self = (FoobarInsetContainer*)widget; + if ( !self->child ) { return; } + + GtkAllocation allocation = + { + .width = MAX( 0, width - 2 * self->inset_horizontal ), + .height = MAX( 0, height - 2 * self->inset_vertical ), + .x = self->inset_horizontal, + .y = self->inset_vertical, + }; + gtk_widget_size_allocate( self->child, &allocation, MAX( 0, baseline + self->inset_vertical ) ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new inset container instance. +// +GtkWidget* foobar_inset_container_new( void ) +{ + return g_object_new( FOOBAR_TYPE_INSET_CONTAINER, NULL ); +} + +// +// Get the container's child widget. +// +GtkWidget* foobar_inset_container_get_child( FoobarInsetContainer* self ) +{ + g_return_val_if_fail( FOOBAR_IS_INSET_CONTAINER( self ), NULL ); + return self->child; +} + +// +// Get the inset applied to the left and right side of the widget. +// +gint foobar_inset_container_get_inset_horizontal( FoobarInsetContainer* self ) +{ + g_return_val_if_fail( FOOBAR_IS_INSET_CONTAINER( self ), 0 ); + return self->inset_horizontal; +} + +// +// Get the inset applied to the top and bottom side of the widget. +// +gint foobar_inset_container_get_inset_vertical( FoobarInsetContainer* self ) +{ + g_return_val_if_fail( FOOBAR_IS_INSET_CONTAINER( self ), 0 ); + return self->inset_vertical; +} + +// +// Update the container's child widget. +// +void foobar_inset_container_set_child( + FoobarInsetContainer* self, + GtkWidget* child ) +{ + g_return_if_fail( FOOBAR_IS_INSET_CONTAINER( self ) ); + g_return_if_fail( child == NULL || self->child == child || gtk_widget_get_parent( child ) == NULL ); + + if ( self->child != child ) + { + g_clear_pointer( &self->child, gtk_widget_unparent ); + + if ( child ) + { + self->child = child; + gtk_widget_set_parent( child, GTK_WIDGET( self ) ); + } + + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CHILD] ); + } +} + +// +// Update the inset applied to the left and right side of the widget. +// +void foobar_inset_container_set_inset_horizontal( + FoobarInsetContainer* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_INSET_CONTAINER( self ) ); + + if ( self->inset_horizontal != value ) + { + self->inset_horizontal = value; + gtk_widget_queue_resize( GTK_WIDGET( self ) ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_INSET_HORIZONTAL] ); + } +} + +// +// Update the inset applied to the top and bottom side of the widget. +// +void foobar_inset_container_set_inset_vertical( + FoobarInsetContainer* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_INSET_CONTAINER( self ) ); + + if ( self->inset_vertical != value ) + { + self->inset_vertical = value; + gtk_widget_queue_resize( GTK_WIDGET( self ) ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_INSET_VERTICAL] ); + } +}
\ No newline at end of file diff --git a/src/widgets/inset-container.h b/src/widgets/inset-container.h new file mode 100644 index 0000000..af0e6b1 --- /dev/null +++ b/src/widgets/inset-container.h @@ -0,0 +1,22 @@ +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_INSET_CONTAINER foobar_inset_container_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarInsetContainer, foobar_inset_container, FOOBAR, INSET_CONTAINER, GtkWidget ) + +GtkWidget* foobar_inset_container_new ( void ); +GtkWidget* foobar_inset_container_get_child ( FoobarInsetContainer* self ); +gint foobar_inset_container_get_inset_horizontal( FoobarInsetContainer* self ); +gint foobar_inset_container_get_inset_vertical ( FoobarInsetContainer* self ); +void foobar_inset_container_set_child ( FoobarInsetContainer* self, + GtkWidget* value ); +void foobar_inset_container_set_inset_horizontal( FoobarInsetContainer* self, + gint value ); +void foobar_inset_container_set_inset_vertical ( FoobarInsetContainer* self, + gint value ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/limit-container.c b/src/widgets/limit-container.c new file mode 100644 index 0000000..d0686ef --- /dev/null +++ b/src/widgets/limit-container.c @@ -0,0 +1,341 @@ +#include "widgets/limit-container.h" + +// +// FoobarLimitContainer: +// +// A container which uses the natural size requested by the child as its minimum size, but only up to a certain point. +// +// This is useful because gtk_scrolled_window_set_max_content_height doesn't seem to be doing what I understand it to +// do. This way, we can set propagate_natural_height to TRUE and then limit the height through this container. +// + +struct _FoobarLimitContainer +{ + GtkWidget parent_instance; + GtkWidget* child; + gint max_width; + gint max_height; +}; + +enum +{ + PROP_CHILD = 1, + PROP_MAX_WIDTH, + PROP_MAX_HEIGHT, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_limit_container_class_init ( FoobarLimitContainerClass* klass ); +static void foobar_limit_container_init ( FoobarLimitContainer* self ); +static void foobar_limit_container_get_property ( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_limit_container_set_property ( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_limit_container_dispose ( GObject* object ); +static GtkSizeRequestMode foobar_limit_container_get_request_mode( GtkWidget* widget ); +static void foobar_limit_container_measure ( GtkWidget* widget, + GtkOrientation orientation, + int for_size, + int* minimum, + int* natural, + int* minimum_baseline, + int* natural_baseline ); +static void foobar_limit_container_size_allocate ( GtkWidget* widget, + int width, + int height, + int baseline ); + +G_DEFINE_FINAL_TYPE( FoobarLimitContainer, foobar_limit_container, GTK_TYPE_WIDGET ) + +// --------------------------------------------------------------------------------------------------------------------- +// Widget Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for limit containers. +// +void foobar_limit_container_class_init( FoobarLimitContainerClass* klass ) +{ + GtkWidgetClass* widget_klass = GTK_WIDGET_CLASS( klass ); + widget_klass->get_request_mode = foobar_limit_container_get_request_mode; + widget_klass->measure = foobar_limit_container_measure; + widget_klass->size_allocate = foobar_limit_container_size_allocate; + gtk_widget_class_set_css_name( widget_klass, "limit-container" ); + + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_limit_container_get_property; + object_klass->set_property = foobar_limit_container_set_property; + object_klass->dispose = foobar_limit_container_dispose; + + props[PROP_CHILD] = g_param_spec_object( + "child", + "Child", + "Child widget for the panel item.", + GTK_TYPE_WIDGET, + G_PARAM_READWRITE ); + props[PROP_MAX_WIDTH] = g_param_spec_int( + "max-width", + "Max Width", + "The maximum natural width supported as a minimum size.", + 0, + INT_MAX, + 0, + G_PARAM_READWRITE ); + props[PROP_MAX_HEIGHT] = g_param_spec_int( + "max-height", + "Max Height", + "The maximum natural height supported as a minimum size.", + 0, + INT_MAX, + 0, + G_PARAM_READWRITE ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for limit containers. +// +void foobar_limit_container_init( FoobarLimitContainer* self ) +{ + (void)self; +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_limit_container_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarLimitContainer* self = (FoobarLimitContainer*)object; + + switch ( prop_id ) + { + case PROP_CHILD: + g_value_set_object( value, foobar_limit_container_get_child( self ) ); + break; + case PROP_MAX_WIDTH: + g_value_set_int( value, foobar_limit_container_get_max_width( self ) ); + break; + case PROP_MAX_HEIGHT: + g_value_set_int( value, foobar_limit_container_get_max_height( self ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_limit_container_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarLimitContainer* self = (FoobarLimitContainer*)object; + + switch ( prop_id ) + { + case PROP_CHILD: + foobar_limit_container_set_child( self, g_value_get_object( value ) ); + break; + case PROP_MAX_WIDTH: + foobar_limit_container_set_max_width( self, g_value_get_int( value ) ); + break; + case PROP_MAX_HEIGHT: + foobar_limit_container_set_max_height( self, g_value_get_int( value ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance de-initialization for limit containers. +// +void foobar_limit_container_dispose( GObject* object ) +{ + FoobarLimitContainer* self = (FoobarLimitContainer*)object; + + g_clear_pointer( &self->child, gtk_widget_unparent ); + + G_OBJECT_CLASS( foobar_limit_container_parent_class )->dispose( object ); +} + +// +// Determine the size request mode used to measure the widget. +// +// This implementation just forwards the request mode from the child widget. +// +GtkSizeRequestMode foobar_limit_container_get_request_mode( GtkWidget* widget ) +{ + FoobarLimitContainer* self = (FoobarLimitContainer*)widget; + if ( !self->child ) { return GTK_SIZE_REQUEST_CONSTANT_SIZE; } + + return gtk_widget_get_request_mode( self->child ); +} + +// +// Compute the requested size of the widget. +// +void foobar_limit_container_measure( + GtkWidget* widget, + GtkOrientation orientation, + int for_size, + int* minimum, + int* natural, + int* minimum_baseline, + int* natural_baseline ) +{ + FoobarLimitContainer* self = (FoobarLimitContainer*)widget; + if ( !self->child ) + { + *minimum = 0; + *natural = 0; + *minimum_baseline = 0; + *natural_baseline = 0; + return; + } + + gtk_widget_measure( self->child, orientation, for_size, minimum, natural, minimum_baseline, natural_baseline ); + gint natural_minimum = *natural; + switch ( orientation ) + { + case GTK_ORIENTATION_HORIZONTAL: + natural_minimum = MIN( natural_minimum, self->max_width ); + break; + case GTK_ORIENTATION_VERTICAL: + natural_minimum = MIN( natural_minimum, self->max_height ); + break; + default: + g_warn_if_reached( ); + break; + } + *minimum = MAX( *minimum, natural_minimum ); +} + +// +// Arrange the child widget. +// +void foobar_limit_container_size_allocate( + GtkWidget* widget, + int width, + int height, + int baseline ) +{ + FoobarLimitContainer* self = (FoobarLimitContainer*)widget; + if ( !self->child ) { return; } + + gtk_widget_allocate( self->child, width, height, baseline, NULL ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new limit container instance. +// +GtkWidget* foobar_limit_container_new( void ) +{ + return g_object_new( FOOBAR_TYPE_LIMIT_CONTAINER, NULL ); +} + +// +// Get the container's child widget. +// +GtkWidget* foobar_limit_container_get_child( FoobarLimitContainer* self ) +{ + g_return_val_if_fail( FOOBAR_IS_LIMIT_CONTAINER( self ), NULL ); + return self->child; +} + +// +// Get the maximum natural width of the child to use as the minimum width for this container. +// +gint foobar_limit_container_get_max_width( FoobarLimitContainer* self ) +{ + g_return_val_if_fail( FOOBAR_IS_LIMIT_CONTAINER( self ), 0 ); + return self->max_width; +} + +// +// Get the maximum natural height of the child to use as the minimum height for this container. +// +gint foobar_limit_container_get_max_height( FoobarLimitContainer* self ) +{ + g_return_val_if_fail( FOOBAR_IS_LIMIT_CONTAINER( self ), 0 ); + return self->max_height; +} + +// +// Update the container's child widget. +// +void foobar_limit_container_set_child( + FoobarLimitContainer* self, + GtkWidget* child ) +{ + g_return_if_fail( FOOBAR_IS_LIMIT_CONTAINER( self ) ); + g_return_if_fail( child == NULL || self->child == child || gtk_widget_get_parent( child ) == NULL ); + + if ( self->child != child ) + { + g_clear_pointer( &self->child, gtk_widget_unparent ); + + if ( child ) + { + self->child = child; + gtk_widget_set_parent( child, GTK_WIDGET( self ) ); + } + + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CHILD] ); + } +} + +// +// Update the maximum natural width of the child to use as the minimum width for this container. +// +void foobar_limit_container_set_max_width( + FoobarLimitContainer* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_LIMIT_CONTAINER( self ) ); + g_return_if_fail( value >= 0 ); + + if ( self->max_width != value ) + { + self->max_width = value; + gtk_widget_queue_resize( GTK_WIDGET( self ) ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_MAX_WIDTH] ); + } +} + +// +// Update the maximum natural height of the child to use as the minimum height for this container. +// +void foobar_limit_container_set_max_height( + FoobarLimitContainer* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_LIMIT_CONTAINER( self ) ); + g_return_if_fail( value >= 0 ); + + if ( self->max_height != value ) + { + self->max_height = value; + gtk_widget_queue_resize( GTK_WIDGET( self ) ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_MAX_HEIGHT] ); + } +}
\ No newline at end of file diff --git a/src/widgets/limit-container.h b/src/widgets/limit-container.h new file mode 100644 index 0000000..c5e7e70 --- /dev/null +++ b/src/widgets/limit-container.h @@ -0,0 +1,22 @@ +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_LIMIT_CONTAINER foobar_limit_container_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarLimitContainer, foobar_limit_container, FOOBAR, LIMIT_CONTAINER, GtkWidget ) + +GtkWidget* foobar_limit_container_new ( void ); +GtkWidget* foobar_limit_container_get_child ( FoobarLimitContainer* self ); +gint foobar_limit_container_get_max_width ( FoobarLimitContainer* self ); +gint foobar_limit_container_get_max_height( FoobarLimitContainer* self ); +void foobar_limit_container_set_child ( FoobarLimitContainer* self, + GtkWidget* value ); +void foobar_limit_container_set_max_width ( FoobarLimitContainer* self, + gint value ); +void foobar_limit_container_set_max_height( FoobarLimitContainer* self, + gint value ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/meson.build b/src/widgets/meson.build new file mode 100644 index 0000000..c6baefc --- /dev/null +++ b/src/widgets/meson.build @@ -0,0 +1,8 @@ +foobar_sources += files( + 'inset-container.c', + 'limit-container.c', + 'notification-widget.c', +) + +subdir('control-center') +subdir('panel')
\ No newline at end of file diff --git a/src/widgets/notification-widget.c b/src/widgets/notification-widget.c new file mode 100644 index 0000000..477a57c --- /dev/null +++ b/src/widgets/notification-widget.c @@ -0,0 +1,821 @@ +#include "widgets/notification-widget.h" + +// +// FoobarNotificationCloseAction: +// +// The action invoked when the user requests to "close" the notification. The notification is either marked as +// "dismissed" and kept around or removed from the list. +// + +G_DEFINE_ENUM_TYPE( + FoobarNotificationCloseAction, + foobar_notification_close_action, + G_DEFINE_ENUM_VALUE( FOOBAR_TYPE_NOTIFICATION_CLOSE_ACTION_REMOVE, "remove" ), + G_DEFINE_ENUM_VALUE( FOOBAR_TYPE_NOTIFICATION_CLOSE_ACTION_DISMISS, "dismiss" ) ) + +// +// FoobarNotificationWidget: +// +// Shared widget for displaying a notification. The widget also manages an inset/margin -- this is done to allow the +// "close" button to extend into the margin area. +// + +struct _FoobarNotificationWidget +{ + GtkWidget parent_instance; + GtkWidget* container; + GtkWidget* content; + GtkWidget* close_button; + FoobarNotification* notification; + FoobarNotificationCloseAction close_action; + gchar* time_format; + gint min_height; + gint close_button_inset; + gint inset_start; + gint inset_end; + gint inset_top; + gint inset_bottom; +}; + +enum +{ + PROP_NOTIFICATION = 1, + PROP_CLOSE_ACTION, + PROP_TIME_FORMAT, + PROP_MIN_HEIGHT, + PROP_CLOSE_BUTTON_INSET, + PROP_INSET_START, + PROP_INSET_END, + PROP_INSET_TOP, + PROP_INSET_BOTTOM, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_notification_widget_class_init ( FoobarNotificationWidgetClass* klass ); +static void foobar_notification_widget_init ( FoobarNotificationWidget* self ); +static void foobar_notification_widget_get_property ( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_notification_widget_set_property ( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_notification_widget_dispose ( GObject* object ); +static void foobar_notification_widget_finalize ( GObject* object ); +static void foobar_notification_widget_handle_enter ( GtkEventControllerMotion* controller, + gdouble x, + gdouble y, + gpointer userdata ); +static void foobar_notification_widget_handle_leave ( GtkEventControllerMotion* controller, + gpointer userdata ); +static void foobar_notification_widget_handle_close_clicked( GtkButton* button, + gpointer userdata ); +static gchar* foobar_notification_widget_compute_time_label ( GtkExpression* expression, + GDateTime* time, + gchar const* format, + gpointer userdata ); +static gboolean foobar_notification_widget_compute_icon_visible( GtkExpression* expression, + GIcon* icon, + gpointer userdata ); +static gboolean foobar_notification_widget_compute_body_visible( GtkExpression* expression, + gchar const* body, + gpointer userdata ); +static void foobar_notification_widget_update_margins ( FoobarNotificationWidget* self ); + +G_DEFINE_FINAL_TYPE( FoobarNotificationWidget, foobar_notification_widget, GTK_TYPE_WIDGET ) + +// --------------------------------------------------------------------------------------------------------------------- +// Widget Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for notifications. +// +void foobar_notification_widget_class_init( FoobarNotificationWidgetClass* klass ) +{ + GtkWidgetClass* widget_klass = GTK_WIDGET_CLASS( klass ); + gtk_widget_class_set_layout_manager_type( widget_klass, GTK_TYPE_BIN_LAYOUT ); + gtk_widget_class_set_css_name( widget_klass, "notification" ); + + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_notification_widget_get_property; + object_klass->set_property = foobar_notification_widget_set_property; + object_klass->dispose = foobar_notification_widget_dispose; + object_klass->finalize = foobar_notification_widget_finalize; + + props[PROP_NOTIFICATION] = g_param_spec_object( + "notification", + "Notification", + "Content to display.", + FOOBAR_TYPE_NOTIFICATION, + G_PARAM_READWRITE ); + props[PROP_CLOSE_ACTION] = g_param_spec_enum( + "close-action", + "Close Action", + "Action to execute when the notification is closed.", + FOOBAR_TYPE_NOTIFICATION_CLOSE_ACTION, + 0, + G_PARAM_READWRITE ); + props[PROP_TIME_FORMAT] = g_param_spec_string( + "time-format", + "Time Format", + "Time format used to display the notification's timestamp.", + NULL, + G_PARAM_READWRITE ); + props[PROP_MIN_HEIGHT] = g_param_spec_int( + "min-height", + "Minimum Height", + "Minimum requested height for the notification itself.", + 0, + INT_MAX, + 0, + G_PARAM_READWRITE ); + props[PROP_CLOSE_BUTTON_INSET] = g_param_spec_int( + "close-button-inset", + "Close Button Inset", + "Offset of the close button within the notification (may be negative, possibly increasing the actual inset).", + INT_MIN, + INT_MAX, + 0, + G_PARAM_READWRITE ); + props[PROP_INSET_START] = g_param_spec_int( + "inset-start", + "Inset Start", + "Inset for the start edge of the widget.", + 0, + INT_MAX, + 0, + G_PARAM_READWRITE ); + props[PROP_INSET_END] = g_param_spec_int( + "inset-end", + "Inset End", + "Inset for the end edge of the widget.", + 0, + INT_MAX, + 0, + G_PARAM_READWRITE ); + props[PROP_INSET_TOP] = g_param_spec_int( + "inset-top", + "Inset Top", + "Inset for the top edge of the widget.", + 0, + INT_MAX, + 0, + G_PARAM_READWRITE ); + props[PROP_INSET_BOTTOM] = g_param_spec_int( + "inset-bottom", + "Inset Bottom", + "Inset for the bottom edge of the widget.", + 0, + INT_MAX, + 0, + G_PARAM_READWRITE ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for notifications. +// +void foobar_notification_widget_init( FoobarNotificationWidget* self ) +{ + // Set up the main notification content. + + GtkWidget* icon = gtk_image_new( ); + gtk_widget_add_css_class( icon, "icon" ); + gtk_widget_set_valign( icon, GTK_ALIGN_CENTER ); + + GtkWidget* title = gtk_label_new( NULL ); + gtk_label_set_justify( GTK_LABEL( title ), GTK_JUSTIFY_LEFT ); + gtk_label_set_ellipsize( GTK_LABEL( title ), PANGO_ELLIPSIZE_END ); + gtk_label_set_wrap( GTK_LABEL( title ), FALSE ); + gtk_label_set_xalign( GTK_LABEL( title ), 0 ); + gtk_widget_add_css_class( title, "title" ); + gtk_widget_set_valign( title, GTK_ALIGN_BASELINE_CENTER ); + gtk_widget_set_hexpand( title, TRUE ); + + GtkWidget* time = gtk_label_new( NULL ); + gtk_label_set_wrap( GTK_LABEL( time ), FALSE ); + gtk_widget_add_css_class( time, "time" ); + gtk_widget_set_valign( time, GTK_ALIGN_BASELINE_CENTER ); + + GtkWidget* body = gtk_label_new( NULL ); + gtk_label_set_use_markup( GTK_LABEL( body ), TRUE ); + gtk_label_set_justify( GTK_LABEL( body ), GTK_JUSTIFY_LEFT ); + gtk_label_set_ellipsize( GTK_LABEL( body ), PANGO_ELLIPSIZE_END ); + gtk_label_set_wrap( GTK_LABEL( body ), TRUE ); + gtk_label_set_wrap_mode( GTK_LABEL( body ), PANGO_WRAP_WORD_CHAR ); + // XXX: Increase once layout is fixed in GTK (https://gitlab.gnome.org/GNOME/gtk/-/issues/5885) + gtk_label_set_lines( GTK_LABEL( body ), 1 ); + gtk_label_set_xalign( GTK_LABEL( body ), 0 ); + gtk_widget_add_css_class( body, "body" ); + + GtkWidget* header = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ); + gtk_box_append( GTK_BOX( header ), title ); + gtk_box_append( GTK_BOX( header ), time ); + + GtkWidget* row = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 ); + gtk_box_append( GTK_BOX( row ), header ); + gtk_box_append( GTK_BOX( row ), body ); + gtk_widget_set_hexpand( row, TRUE ); + gtk_widget_set_valign( row, GTK_ALIGN_CENTER ); + + self->content = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ); + gtk_box_append( GTK_BOX( self->content ), icon ); + gtk_box_append( GTK_BOX( self->content ), row ); + gtk_widget_add_css_class( self->content, "content" ); + + // Set up the overlay for the close button. + + GtkWidget* close_icon = gtk_image_new_from_icon_name( "fluent-dismiss-symbolic" ); + gtk_image_set_pixel_size( GTK_IMAGE( close_icon ), 12 ); + + self->close_button = gtk_button_new( ); + gtk_button_set_child( GTK_BUTTON( self->close_button ), close_icon ); + gtk_widget_add_css_class( self->close_button, "close-button" ); + gtk_widget_set_visible( self->close_button, FALSE ); + gtk_widget_set_halign( self->close_button, GTK_ALIGN_END ); + gtk_widget_set_valign( self->close_button, GTK_ALIGN_START ); + g_signal_connect( self->close_button, "clicked", G_CALLBACK( foobar_notification_widget_handle_close_clicked ), self ); + + GtkEventController* hover_controller = gtk_event_controller_motion_new( ); + g_signal_connect( hover_controller, "enter", G_CALLBACK( foobar_notification_widget_handle_enter ), self ); + g_signal_connect( hover_controller, "leave", G_CALLBACK( foobar_notification_widget_handle_leave ), self ); + + self->container = gtk_overlay_new( ); + gtk_overlay_set_child( GTK_OVERLAY( self->container ), self->content ); + gtk_overlay_add_overlay( GTK_OVERLAY( self->container ), self->close_button ); + gtk_widget_add_controller( self->container, hover_controller ); + gtk_widget_set_parent( self->container, GTK_WIDGET( self ) ); + + // Set up bindings. + + { + GtkExpression* notification_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION_WIDGET, NULL, "notification" ); + GtkExpression* image_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION, notification_expr, "image" ); + gtk_expression_bind( gtk_expression_ref( image_expr ), icon, "gicon", self ); + GtkExpression* visible_params[] = { image_expr }; + GtkExpression* visible_expr = gtk_cclosure_expression_new( + G_TYPE_BOOLEAN, + NULL, + G_N_ELEMENTS( visible_params ), + visible_params, + G_CALLBACK( foobar_notification_widget_compute_icon_visible ), + NULL, + NULL ); + gtk_expression_bind( visible_expr, icon, "visible", self ); + } + + { + GtkExpression* notification_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION_WIDGET, NULL, "notification" ); + GtkExpression* summary_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION, notification_expr, "summary" ); + gtk_expression_bind( summary_expr, title, "label", self ); + } + + { + GtkExpression* notification_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION_WIDGET, NULL, "notification" ); + GtkExpression* body_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION, notification_expr, "body" ); + gtk_expression_bind( gtk_expression_ref( body_expr ), body, "label", self ); + GtkExpression* visible_params[] = { body_expr }; + GtkExpression* visible_expr = gtk_cclosure_expression_new( + G_TYPE_BOOLEAN, + NULL, + G_N_ELEMENTS( visible_params ), + visible_params, + G_CALLBACK( foobar_notification_widget_compute_body_visible ), + NULL, + NULL ); + gtk_expression_bind( visible_expr, body, "visible", self ); + } + + { + GtkExpression* notification_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION_WIDGET, NULL, "notification" ); + GtkExpression* time_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION, notification_expr, "time" ); + GtkExpression* format_expr = gtk_property_expression_new( FOOBAR_TYPE_NOTIFICATION_WIDGET, NULL, "time-format" ); + GtkExpression* str_params[] = { time_expr, format_expr }; + GtkExpression* str_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( str_params ), + str_params, + G_CALLBACK( foobar_notification_widget_compute_time_label ), + self, + NULL ); + gtk_expression_bind( str_expr, time, "label", self ); + } +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_notification_widget_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarNotificationWidget* self = (FoobarNotificationWidget*)object; + + switch ( prop_id ) + { + case PROP_NOTIFICATION: + g_value_set_object( value, foobar_notification_widget_get_notification( self ) ); + break; + case PROP_CLOSE_ACTION: + g_value_set_enum( value, foobar_notification_widget_get_close_action( self ) ); + break; + case PROP_TIME_FORMAT: + g_value_set_string( value, foobar_notification_widget_get_time_format( self ) ); + break; + case PROP_MIN_HEIGHT: + g_value_set_int( value, foobar_notification_widget_get_min_height( self ) ); + break; + case PROP_CLOSE_BUTTON_INSET: + g_value_set_int( value, foobar_notification_widget_get_close_button_inset( self ) ); + break; + case PROP_INSET_START: + g_value_set_int( value, foobar_notification_widget_get_inset_start( self ) ); + break; + case PROP_INSET_END: + g_value_set_int( value, foobar_notification_widget_get_inset_end( self ) ); + break; + case PROP_INSET_TOP: + g_value_set_int( value, foobar_notification_widget_get_inset_top( self ) ); + break; + case PROP_INSET_BOTTOM: + g_value_set_int( value, foobar_notification_widget_get_inset_bottom( self ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_notification_widget_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarNotificationWidget* self = (FoobarNotificationWidget*)object; + + switch ( prop_id ) + { + case PROP_NOTIFICATION: + foobar_notification_widget_set_notification( self, g_value_get_object( value ) ); + break; + case PROP_CLOSE_ACTION: + foobar_notification_widget_set_close_action( self, g_value_get_enum( value ) ); + break; + case PROP_TIME_FORMAT: + foobar_notification_widget_set_time_format( self, g_value_get_string( value ) ); + break; + case PROP_MIN_HEIGHT: + foobar_notification_widget_set_min_height( self, g_value_get_int( value ) ); + break; + case PROP_CLOSE_BUTTON_INSET: + foobar_notification_widget_set_close_button_inset( self, g_value_get_int( value ) ); + break; + case PROP_INSET_START: + foobar_notification_widget_set_inset_start( self, g_value_get_int( value ) ); + break; + case PROP_INSET_END: + foobar_notification_widget_set_inset_end( self, g_value_get_int( value ) ); + break; + case PROP_INSET_TOP: + foobar_notification_widget_set_inset_top( self, g_value_get_int( value ) ); + break; + case PROP_INSET_BOTTOM: + foobar_notification_widget_set_inset_bottom( self, g_value_get_int( value ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance de-initialization for notifications. +// +void foobar_notification_widget_dispose( GObject* object ) +{ + FoobarNotificationWidget* self = (FoobarNotificationWidget*)object; + + GtkWidget* child; + while ( ( child = gtk_widget_get_first_child( GTK_WIDGET( self ) ) ) ) + { + gtk_widget_unparent( child ); + } + + G_OBJECT_CLASS( foobar_notification_widget_parent_class )->dispose( object ); +} + +// +// Instance cleanup for notifications. +// +void foobar_notification_widget_finalize( GObject* object ) +{ + FoobarNotificationWidget* self = (FoobarNotificationWidget*)object; + + g_clear_object( &self->notification ); + g_clear_pointer( &self->time_format, g_free ); + + G_OBJECT_CLASS( foobar_notification_widget_parent_class )->finalize( object ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new notification widget instance. +// +GtkWidget* foobar_notification_widget_new( void ) +{ + return g_object_new( FOOBAR_TYPE_NOTIFICATION_WIDGET, NULL ); +} + +// +// Get the notification model currently displayed. +// +FoobarNotification* foobar_notification_widget_get_notification( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), NULL ); + return self->notification; +} + +// +// Get the action invoked when the user wants to "close" a notification. +// +FoobarNotificationCloseAction foobar_notification_widget_get_close_action( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), 0 ); + return self->close_action; +} + +// +// Get the time format string used to display the notification's timestamp. +// +gchar const* foobar_notification_widget_get_time_format( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), NULL ); + return self->time_format; +} + +// +// Get the minimum height of the notification (excluding the inset). +// +gint foobar_notification_widget_get_min_height( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), 0 ); + return self->min_height; +} + +// +// Get the offset of the close button within the notification (may be negative, possibly increasing the actual inset). +// +gint foobar_notification_widget_get_close_button_inset( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), 0 ); + return self->close_button_inset; +} + +// +// Get the margin for the start edge of the notification. +// +gint foobar_notification_widget_get_inset_start( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), 0 ); + return self->inset_start; +} + +// +// Get the margin for the end edge of the notification. +// +gint foobar_notification_widget_get_inset_end( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), 0 ); + return self->inset_end; +} + +// +// Get the margin for the top edge of the notification. +// +gint foobar_notification_widget_get_inset_top( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), 0 ); + return self->inset_top; +} + +// +// Get the margin for the bottom edge of the notification. +// +gint foobar_notification_widget_get_inset_bottom( FoobarNotificationWidget* self ) +{ + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ), 0 ); + return self->inset_bottom; +} + +// +// Update the notification model currently displayed. +// +void foobar_notification_widget_set_notification( + FoobarNotificationWidget* self, + FoobarNotification* value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + if ( self->notification != value ) + { + g_clear_object( &self->notification ); + if ( value ) { self->notification = g_object_ref( value ); } + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_NOTIFICATION] ); + } +} + +// +// Update the action invoked when the user wants to "close" a notification. +// +void foobar_notification_widget_set_close_action( + FoobarNotificationWidget* self, + FoobarNotificationCloseAction value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + if ( self->close_action != value ) + { + self->close_action = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CLOSE_ACTION] ); + } +} + +// +// Update the time format string used to display the notification's timestamp. +// +void foobar_notification_widget_set_time_format( + FoobarNotificationWidget* self, + gchar const* value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + if ( g_strcmp0( self->time_format, value ) ) + { + g_clear_pointer( &self->time_format, g_free ); + self->time_format = g_strdup( value ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_TIME_FORMAT] ); + } +} + +// +// Update the minimum height of the notification (excluding the inset). +// +void foobar_notification_widget_set_min_height( + FoobarNotificationWidget* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + value = MAX( value, 0 ); + if ( self->min_height != value ) + { + self->min_height = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_MIN_HEIGHT] ); + gtk_widget_set_size_request( self->content, -1, self->min_height ); + } +} + +// +// Update the offset of the close button within the notification (may be negative, possibly increasing the actual inset). +// +void foobar_notification_widget_set_close_button_inset( + FoobarNotificationWidget* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + if ( self->close_button_inset != value ) + { + self->close_button_inset = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CLOSE_BUTTON_INSET] ); + foobar_notification_widget_update_margins( self ); + } +} + +// +// Update the margin for the start edge of the notification. +// +void foobar_notification_widget_set_inset_start( + FoobarNotificationWidget* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + value = MAX( value, 0 ); + if ( self->inset_start != value ) + { + self->inset_start = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_INSET_START] ); + foobar_notification_widget_update_margins( self ); + } +} + +// +// Update the margin for the end edge of the notification. +// +void foobar_notification_widget_set_inset_end( + FoobarNotificationWidget* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + value = MAX( value, 0 ); + if ( self->inset_end != value ) + { + self->inset_end = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_INSET_END] ); + foobar_notification_widget_update_margins( self ); + } +} + +// +// Update the margin for the top edge of the notification. +// +void foobar_notification_widget_set_inset_top( + FoobarNotificationWidget* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + value = MAX( value, 0 ); + if ( self->inset_top != value ) + { + self->inset_top = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_INSET_TOP] ); + foobar_notification_widget_update_margins( self ); + } +} + +// +// Update the margin for the bottom edge of the notification. +// +void foobar_notification_widget_set_inset_bottom( + FoobarNotificationWidget* self, + gint value ) +{ + g_return_if_fail( FOOBAR_IS_NOTIFICATION_WIDGET( self ) ); + + value = MAX( value, 0 ); + if ( self->inset_bottom != value ) + { + self->inset_bottom = value; + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_INSET_BOTTOM] ); + foobar_notification_widget_update_margins( self ); + } +} + +// --------------------------------------------------------------------------------------------------------------------- +// Signal Handlers +// --------------------------------------------------------------------------------------------------------------------- + +// +// Called when the mouse cursor enters the notification. +// +// We will temporarily block the dismissal timeout for the notification and show the close button. +// +void foobar_notification_widget_handle_enter( + GtkEventControllerMotion* controller, + gdouble x, + gdouble y, + gpointer userdata ) +{ + (void)controller; + (void)x; + (void)y; + FoobarNotificationWidget* self = (FoobarNotificationWidget*)userdata; + + gtk_widget_set_visible( self->close_button, TRUE ); + if ( self->notification ) { foobar_notification_block_timeout( self->notification ); } +} + +// +// Called when the mouse cursor leaves the notification. +// +// We will unblock the dismissal timeout for the notification and hide the close button. +// +void foobar_notification_widget_handle_leave( + GtkEventControllerMotion* controller, + gpointer userdata ) +{ + (void)controller; + FoobarNotificationWidget* self = (FoobarNotificationWidget*)userdata; + + gtk_widget_set_visible( self->close_button, FALSE ); + if ( self->notification ) { foobar_notification_resume_timeout( self->notification ); } +} + +// +// Called when the user has clicked the "close" button. +// +// This either marks the notification as dismissed or removes it. +// +void foobar_notification_widget_handle_close_clicked( + GtkButton* button, + gpointer userdata ) +{ + (void)button; + FoobarNotificationWidget* self = (FoobarNotificationWidget*)userdata; + + if ( self->notification ) + { + switch ( self->close_action ) + { + case FOOBAR_TYPE_NOTIFICATION_CLOSE_ACTION_REMOVE: + foobar_notification_close( self->notification ); + break; + case FOOBAR_TYPE_NOTIFICATION_CLOSE_ACTION_DISMISS: + foobar_notification_dismiss( self->notification ); + break; + default: + g_warn_if_reached( ); + break; + } + } +} + +// --------------------------------------------------------------------------------------------------------------------- +// Value Converters +// --------------------------------------------------------------------------------------------------------------------- + +// +// Derive the timestamp label value from the notification's timestamp and the selected time format. +// +gchar* foobar_notification_widget_compute_time_label( + GtkExpression* expression, + GDateTime* time, + gchar const* format, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + return format != NULL ? g_date_time_format( time, format ) : NULL; +} + +// +// Derive the visibility of the notification icon from its value. +// +gboolean foobar_notification_widget_compute_icon_visible( + GtkExpression* expression, + GIcon* icon, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + return icon != NULL; +} + +// +// Derive the visibility of the notification body label from its value. +// +gboolean foobar_notification_widget_compute_body_visible( + GtkExpression* expression, + gchar const* body, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + return body != NULL && g_strcmp0( body, "" ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Helper Methods +// --------------------------------------------------------------------------------------------------------------------- + +// +// Update the margins of the content widget and close button to the current inset values. +// +void foobar_notification_widget_update_margins( FoobarNotificationWidget* self ) +{ + gint inset = MAX( self->close_button_inset, 0 ); + gint overrun = MAX( -self->close_button_inset, 0 ); + gint actual_inset_end = MAX( self->inset_end, overrun ); + gint actual_inset_top = MAX( self->inset_top, overrun ); + + gtk_widget_set_margin_start( self->container, self->inset_start ); + gtk_widget_set_margin_end( self->container, actual_inset_end - overrun ); + gtk_widget_set_margin_top( self->container, actual_inset_top - overrun ); + gtk_widget_set_margin_bottom( self->container, self->inset_bottom ); + + gtk_widget_set_margin_end( self->content, overrun ); + gtk_widget_set_margin_top( self->content, overrun ); + + gtk_widget_set_margin_end( self->close_button, inset ); + gtk_widget_set_margin_top( self->close_button, inset ); +}
\ No newline at end of file diff --git a/src/widgets/notification-widget.h b/src/widgets/notification-widget.h new file mode 100644 index 0000000..3c15ee4 --- /dev/null +++ b/src/widgets/notification-widget.h @@ -0,0 +1,50 @@ +#pragma once + +#include <gtk/gtk.h> +#include "services/notification-service.h" + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_NOTIFICATION_CLOSE_ACTION foobar_notification_close_action_get_type( ) +#define FOOBAR_TYPE_NOTIFICATION_WIDGET foobar_notification_widget_get_type( ) + +typedef enum +{ + FOOBAR_TYPE_NOTIFICATION_CLOSE_ACTION_REMOVE, + FOOBAR_TYPE_NOTIFICATION_CLOSE_ACTION_DISMISS, +} FoobarNotificationCloseAction; + +GType foobar_notification_close_action_get_type( void ); + +G_DECLARE_FINAL_TYPE( FoobarNotificationWidget, foobar_notification_widget, FOOBAR, NOTIFICATION_WIDGET, GtkWidget ) + +GtkWidget* foobar_notification_widget_new ( void ); +FoobarNotification* foobar_notification_widget_get_notification ( FoobarNotificationWidget* self ); +FoobarNotificationCloseAction foobar_notification_widget_get_close_action ( FoobarNotificationWidget* self ); +gchar const* foobar_notification_widget_get_time_format ( FoobarNotificationWidget* self ); +gint foobar_notification_widget_get_min_height ( FoobarNotificationWidget* self ); +gint foobar_notification_widget_get_close_button_inset( FoobarNotificationWidget* self ); +gint foobar_notification_widget_get_inset_start ( FoobarNotificationWidget* self ); +gint foobar_notification_widget_get_inset_end ( FoobarNotificationWidget* self ); +gint foobar_notification_widget_get_inset_top ( FoobarNotificationWidget* self ); +gint foobar_notification_widget_get_inset_bottom ( FoobarNotificationWidget* self ); +void foobar_notification_widget_set_notification ( FoobarNotificationWidget* self, + FoobarNotification* value ); +void foobar_notification_widget_set_close_action ( FoobarNotificationWidget* self, + FoobarNotificationCloseAction value ); +void foobar_notification_widget_set_time_format ( FoobarNotificationWidget* self, + gchar const* value ); +void foobar_notification_widget_set_min_height ( FoobarNotificationWidget* self, + gint value ); +void foobar_notification_widget_set_close_button_inset( FoobarNotificationWidget* self, + gint value ); +void foobar_notification_widget_set_inset_start ( FoobarNotificationWidget* self, + gint value ); +void foobar_notification_widget_set_inset_end ( FoobarNotificationWidget* self, + gint value ); +void foobar_notification_widget_set_inset_top ( FoobarNotificationWidget* self, + gint value ); +void foobar_notification_widget_set_inset_bottom ( FoobarNotificationWidget* self, + gint value ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/panel/meson.build b/src/widgets/panel/meson.build new file mode 100644 index 0000000..abddd6d --- /dev/null +++ b/src/widgets/panel/meson.build @@ -0,0 +1,7 @@ +foobar_sources += files( + 'panel-item.c', + 'panel-item-icon.c', + 'panel-item-clock.c', + 'panel-item-workspaces.c', + 'panel-item-status.c', +)
\ No newline at end of file diff --git a/src/widgets/panel/panel-item-clock.c b/src/widgets/panel/panel-item-clock.c new file mode 100644 index 0000000..1efd7fa --- /dev/null +++ b/src/widgets/panel/panel-item-clock.c @@ -0,0 +1,152 @@ +#include "widgets/panel/panel-item-clock.h" + +// +// FoobarPanelItemClock: +// +// A panel item displaying the current time in the format configured by the user. +// + +struct _FoobarPanelItemClock +{ + FoobarPanelItem parent_instance; + gchar* format; + FoobarPanelItemAction action; + GtkWidget* label; + GtkWidget* button; + FoobarClockService* clock_service; +}; + +static void foobar_panel_item_clock_class_init ( FoobarPanelItemClockClass* klass ); +static void foobar_panel_item_clock_init ( FoobarPanelItemClock* self ); +static void foobar_panel_item_clock_finalize ( GObject* object ); +static void foobar_panel_item_clock_handle_clicked( GtkButton* button, + gpointer userdata ); +static gchar* foobar_panel_item_clock_compute_label ( GtkExpression* expression, + GDateTime* time, + gpointer userdata ); + +G_DEFINE_FINAL_TYPE( FoobarPanelItemClock, foobar_panel_item_clock, FOOBAR_TYPE_PANEL_ITEM ) + +// --------------------------------------------------------------------------------------------------------------------- +// Panel Item Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for clock panel items. +// +void foobar_panel_item_clock_class_init( FoobarPanelItemClockClass* klass ) +{ + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->finalize = foobar_panel_item_clock_finalize; +} + +// +// Instance initialization for clock panel items. +// +void foobar_panel_item_clock_init( FoobarPanelItemClock* self ) +{ + self->label = gtk_label_new( NULL ); + gtk_label_set_justify( GTK_LABEL( self->label ), GTK_JUSTIFY_CENTER ); + + self->button = gtk_button_new( ); + gtk_button_set_has_frame( GTK_BUTTON( self->button ), FALSE ); + gtk_button_set_child( GTK_BUTTON( self->button ), self->label ); + gtk_widget_set_halign( self->button, GTK_ALIGN_CENTER ); + gtk_widget_set_valign( self->button, GTK_ALIGN_CENTER ); + g_signal_connect( + self->button, + "clicked", + G_CALLBACK( foobar_panel_item_clock_handle_clicked ), + self ); + + gtk_widget_add_css_class( GTK_WIDGET( self ), "clock" ); + foobar_panel_item_set_child( FOOBAR_PANEL_ITEM( self ), self->button ); +} + +// +// Instance cleanup for clock panel items. +// +void foobar_panel_item_clock_finalize( GObject* object ) +{ + FoobarPanelItemClock* self = (FoobarPanelItemClock*)object; + + g_clear_pointer( &self->format, g_free ); + g_clear_object( &self->clock_service ); + + G_OBJECT_CLASS( foobar_panel_item_clock_parent_class )->finalize( object ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new clock panel item with the given configuration. +// +FoobarPanelItem* foobar_panel_item_clock_new( + FoobarPanelItemConfiguration const* config, + FoobarClockService* clock_service ) +{ + g_return_val_if_fail( config != NULL, NULL ); + g_return_val_if_fail( foobar_panel_item_configuration_get_kind( config ) == FOOBAR_PANEL_ITEM_KIND_CLOCK, NULL ); + g_return_val_if_fail( FOOBAR_IS_CLOCK_SERVICE( clock_service ), NULL ); + + FoobarPanelItemClock* self = g_object_new( FOOBAR_TYPE_PANEL_ITEM_CLOCK, NULL ); + self->format = g_strdup( foobar_panel_item_clock_configuration_get_format( config ) ); + self->action = foobar_panel_item_configuration_get_action( config ); + self->clock_service = g_object_ref( clock_service ); + + gtk_widget_set_sensitive( self->button, self->action != FOOBAR_PANEL_ITEM_ACTION_NONE ); + + { + GtkExpression* service_expr = gtk_constant_expression_new( FOOBAR_TYPE_CLOCK_SERVICE, self->clock_service ); + GtkExpression* time_expr = gtk_property_expression_new( FOOBAR_TYPE_CLOCK_SERVICE, service_expr, "time" ); + GtkExpression* label_params[] = { time_expr }; + GtkExpression* label_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( label_params ), + label_params, + G_CALLBACK( foobar_panel_item_clock_compute_label ), + self, + NULL ); + gtk_expression_bind( label_expr, self->label, "label", NULL ); + } + + return FOOBAR_PANEL_ITEM( self ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Signal Handlers +// --------------------------------------------------------------------------------------------------------------------- + +// +// Called when the button was clicked. +// +void foobar_panel_item_clock_handle_clicked( + GtkButton* button, + gpointer userdata ) +{ + (void)button; + FoobarPanelItemClock* self = (FoobarPanelItemClock*)userdata; + + foobar_panel_item_invoke_action( FOOBAR_PANEL_ITEM( self ), self->action ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Value Converters +// --------------------------------------------------------------------------------------------------------------------- + +// +// Derive the label from a timestamp, depending on the configured time format. +// +gchar* foobar_panel_item_clock_compute_label( + GtkExpression* expression, + GDateTime* time, + gpointer userdata ) +{ + (void)expression; + FoobarPanelItemClock* self = (FoobarPanelItemClock*)userdata; + + return g_date_time_format( time, self->format ); +}
\ No newline at end of file diff --git a/src/widgets/panel/panel-item-clock.h b/src/widgets/panel/panel-item-clock.h new file mode 100644 index 0000000..244da2f --- /dev/null +++ b/src/widgets/panel/panel-item-clock.h @@ -0,0 +1,15 @@ +#pragma once + +#include "widgets/panel/panel-item.h" +#include "services/clock-service.h" + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_PANEL_ITEM_CLOCK foobar_panel_item_clock_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarPanelItemClock, foobar_panel_item_clock, FOOBAR, PANEL_ITEM_CLOCK, FoobarPanelItem ) + +FoobarPanelItem* foobar_panel_item_clock_new( FoobarPanelItemConfiguration const* config, + FoobarClockService* clock_service ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/panel/panel-item-icon.c b/src/widgets/panel/panel-item-icon.c new file mode 100644 index 0000000..327f027 --- /dev/null +++ b/src/widgets/panel/panel-item-icon.c @@ -0,0 +1,92 @@ +#include "widgets/panel/panel-item-icon.h" + +// +// FoobarPanelItemIcon: +// +// Simple item implementation displaying an icon. +// + +struct _FoobarPanelItemIcon +{ + FoobarPanelItem parent_instance; + GtkWidget* button; + FoobarPanelItemAction action; +}; + +static void foobar_panel_item_icon_class_init ( FoobarPanelItemIconClass* klass ); +static void foobar_panel_item_icon_init ( FoobarPanelItemIcon* self ); +static void foobar_panel_item_icon_handle_clicked( GtkButton* button, + gpointer userdata ); + +G_DEFINE_FINAL_TYPE( FoobarPanelItemIcon, foobar_panel_item_icon, FOOBAR_TYPE_PANEL_ITEM ) + +// --------------------------------------------------------------------------------------------------------------------- +// Panel Item Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for icon panel items. +// +void foobar_panel_item_icon_class_init( FoobarPanelItemIconClass* klass ) +{ + (void)klass; +} + +// +// Instance initialization for icon panel items. +// +void foobar_panel_item_icon_init( FoobarPanelItemIcon* self ) +{ + self->button = gtk_button_new( ); + gtk_button_set_has_frame( GTK_BUTTON( self->button ), FALSE ); + gtk_widget_set_halign( self->button, GTK_ALIGN_CENTER ); + gtk_widget_set_valign( self->button, GTK_ALIGN_CENTER ); + g_signal_connect( + self->button, + "clicked", + G_CALLBACK( foobar_panel_item_icon_handle_clicked ), + self ); + + gtk_widget_add_css_class( GTK_WIDGET( self ), "icon" ); + foobar_panel_item_set_child( FOOBAR_PANEL_ITEM( self ), self->button ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new icon panel item with the given configuration. +// +FoobarPanelItem* foobar_panel_item_icon_new( FoobarPanelItemConfiguration const* config ) +{ + g_return_val_if_fail( config != NULL, NULL ); + g_return_val_if_fail( foobar_panel_item_configuration_get_kind( config ) == FOOBAR_PANEL_ITEM_KIND_ICON, NULL ); + + FoobarPanelItemIcon* self = g_object_new( FOOBAR_TYPE_PANEL_ITEM_ICON, NULL ); + self->action = foobar_panel_item_configuration_get_action( config ); + + gtk_widget_set_sensitive( self->button, self->action != FOOBAR_PANEL_ITEM_ACTION_NONE ); + gtk_button_set_icon_name( + GTK_BUTTON( self->button ), + foobar_panel_item_icon_configuration_get_icon_name( config ) ); + + return FOOBAR_PANEL_ITEM( self ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Signal Handlers +// --------------------------------------------------------------------------------------------------------------------- + +// +// Called when the button was clicked. +// +void foobar_panel_item_icon_handle_clicked( + GtkButton* button, + gpointer userdata ) +{ + (void)button; + FoobarPanelItemIcon* self = (FoobarPanelItemIcon*)userdata; + + foobar_panel_item_invoke_action( FOOBAR_PANEL_ITEM( self ), self->action ); +}
\ No newline at end of file diff --git a/src/widgets/panel/panel-item-icon.h b/src/widgets/panel/panel-item-icon.h new file mode 100644 index 0000000..77b1144 --- /dev/null +++ b/src/widgets/panel/panel-item-icon.h @@ -0,0 +1,13 @@ +#pragma once + +#include "widgets/panel/panel-item.h" + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_PANEL_ITEM_ICON foobar_panel_item_icon_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarPanelItemIcon, foobar_panel_item_icon, FOOBAR, PANEL_ITEM_ICON, FoobarPanelItem ) + +FoobarPanelItem* foobar_panel_item_icon_new( FoobarPanelItemConfiguration const* config ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/panel/panel-item-status.c b/src/widgets/panel/panel-item-status.c new file mode 100644 index 0000000..4deacb4 --- /dev/null +++ b/src/widgets/panel/panel-item-status.c @@ -0,0 +1,955 @@ +#include "widgets/panel/panel-item-status.h" + +// +// FoobarPanelItemStatus: +// +// A panel item showing status indicators for various things such as network state, audio volume, screen brightness, +// battery level, etc. +// + +struct _FoobarPanelItemStatus +{ + FoobarPanelItem parent_instance; + FoobarPanelItemAction action; + GtkWidget* button; + GtkWidget* layout; + FoobarBatteryService* battery_service; + FoobarBrightnessService* brightness_service; + FoobarAudioService* audio_service; + FoobarNetworkService* network_service; + FoobarBluetoothService* bluetooth_service; + FoobarNotificationService* notification_service; + GtkWidget* network_icon; + GtkWidget* network_label; + GtkExpression* network_icon_expr; + FoobarNetwork* network; + gulong network_handler_id; + gulong network_strength_handler_id; +}; + +enum +{ + PROP_ORIENTATION = 1, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_panel_item_status_class_init ( FoobarPanelItemStatusClass* klass ); +static void foobar_panel_item_status_init ( FoobarPanelItemStatus* self ); +static void foobar_panel_item_status_get_property ( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_panel_item_status_set_property ( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_panel_item_status_finalize ( GObject* object ); +static void foobar_panel_item_status_handle_network_change ( FoobarNetworkAdapterWifi* adapter, + GParamSpec* pspec, + gpointer userdata ); +static void foobar_panel_item_status_handle_network_strength_change( GObject* object, + GParamSpec* pspec, + gpointer userdata ); +static void foobar_panel_item_status_handle_clicked ( GtkButton* button, + gpointer userdata ); +static gboolean foobar_panel_item_status_handle_brightness_scroll ( GtkEventControllerScroll* controller, + gdouble dx, + gdouble dy, + gpointer userdata ); +static gboolean foobar_panel_item_status_handle_audio_scroll ( GtkEventControllerScroll* controller, + gdouble dx, + gdouble dy, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_network_icon ( GtkExpression* expression, + FoobarNetworkAdapter* adapter, + FoobarNetworkAdapterState state, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_bluetooth_icon ( GtkExpression* expression, + gboolean is_enabled, + guint connected_device_count, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_battery_icon ( GtkExpression* expression, + FoobarBatteryState const* state, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_battery_label ( GtkExpression* expression, + FoobarBatteryState const* state, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_brightness_icon ( GtkExpression* expression, + gint percentage, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_brightness_label ( GtkExpression* expression, + gint percentage, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_audio_icon ( GtkExpression* expression, + gboolean is_available, + gint volume, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_audio_label ( GtkExpression* expression, + gboolean is_available, + gint volume, + gpointer userdata ); +static gchar* foobar_panel_item_status_compute_notifications_icon ( GtkExpression* expression, + guint count, + gpointer userdata ); +static GtkWidget* foobar_panel_item_status_create_item ( FoobarPanelItemStatus* self, + FoobarStatusItem item, + gboolean show_labels, + gboolean enable_scrolling ); +static void foobar_panel_item_status_reevaluate_network ( FoobarPanelItemStatus* self ); + +G_DEFINE_FINAL_TYPE_WITH_CODE( + FoobarPanelItemStatus, + foobar_panel_item_status, + FOOBAR_TYPE_PANEL_ITEM, + G_IMPLEMENT_INTERFACE( GTK_TYPE_ORIENTABLE, NULL ) ) + +// --------------------------------------------------------------------------------------------------------------------- +// Panel Item Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for status panel items. +// +void foobar_panel_item_status_class_init( FoobarPanelItemStatusClass* klass ) +{ + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_panel_item_status_get_property; + object_klass->set_property = foobar_panel_item_status_set_property; + object_klass->finalize = foobar_panel_item_status_finalize; + + gpointer orientable_iface = g_type_default_interface_peek( GTK_TYPE_ORIENTABLE ); + props[PROP_ORIENTATION] = g_param_spec_override( + "orientation", + g_object_interface_find_property( orientable_iface, "orientation" ) ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for status panel items. +// +void foobar_panel_item_status_init( FoobarPanelItemStatus* self ) +{ + self->layout = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 ); + + self->button = gtk_button_new( ); + gtk_button_set_has_frame( GTK_BUTTON( self->button ), FALSE ); + gtk_button_set_child( GTK_BUTTON( self->button ), self->layout ); + gtk_widget_set_halign( self->button, GTK_ALIGN_CENTER ); + gtk_widget_set_valign( self->button, GTK_ALIGN_CENTER ); + g_signal_connect( + self->button, + "clicked", + G_CALLBACK( foobar_panel_item_status_handle_clicked ), + self ); + + gtk_widget_add_css_class( GTK_WIDGET( self ), "status" ); + foobar_panel_item_set_child( FOOBAR_PANEL_ITEM( self ), self->button ); +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_panel_item_status_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarPanelItemStatus* self = (FoobarPanelItemStatus*)object; + + switch ( prop_id ) + { + case PROP_ORIENTATION: + g_value_set_enum( value, gtk_orientable_get_orientation( GTK_ORIENTABLE( self->layout ) ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_panel_item_status_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarPanelItemStatus* self = (FoobarPanelItemStatus*)object; + + switch ( prop_id ) + { + case PROP_ORIENTATION: + gtk_orientable_set_orientation( GTK_ORIENTABLE( self->layout ), g_value_get_enum( value ) ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_ORIENTATION] ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance cleanup for status panel items. +// +void foobar_panel_item_status_finalize( GObject* object ) +{ + FoobarPanelItemStatus* self = (FoobarPanelItemStatus*)object; + + FoobarNetworkAdapterWifi* adapter = foobar_network_service_get_wifi( self->network_service ); + g_clear_signal_handler( &self->network_handler_id, adapter ); + g_clear_signal_handler( &self->network_strength_handler_id, self->network ); + g_clear_object( &self->network ); + g_clear_object( &self->battery_service ); + g_clear_object( &self->brightness_service ); + g_clear_object( &self->audio_service ); + g_clear_object( &self->network_service ); + g_clear_object( &self->bluetooth_service ); + g_clear_object( &self->notification_service ); + g_clear_pointer( &self->network_icon_expr, gtk_expression_unref ); + + G_OBJECT_CLASS( foobar_panel_item_status_parent_class )->finalize( object ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new status panel item with the given configuration. +// +FoobarPanelItem* foobar_panel_item_status_new( + FoobarPanelItemConfiguration const* config, + FoobarBatteryService* battery_service, + FoobarBrightnessService* brightness_service, + FoobarAudioService* audio_service, + FoobarNetworkService* network_service, + FoobarBluetoothService* bluetooth_service, + FoobarNotificationService* notification_service ) +{ + g_return_val_if_fail( config != NULL, NULL ); + g_return_val_if_fail( foobar_panel_item_configuration_get_kind( config ) == FOOBAR_PANEL_ITEM_KIND_STATUS, NULL ); + g_return_val_if_fail( FOOBAR_IS_BATTERY_SERVICE( battery_service ), NULL ); + g_return_val_if_fail( FOOBAR_IS_BRIGHTNESS_SERVICE( brightness_service ), NULL ); + g_return_val_if_fail( FOOBAR_IS_AUDIO_SERVICE( audio_service ), NULL ); + g_return_val_if_fail( FOOBAR_IS_NETWORK_SERVICE( network_service ), NULL ); + g_return_val_if_fail( FOOBAR_IS_BLUETOOTH_SERVICE( bluetooth_service ), NULL ); + g_return_val_if_fail( FOOBAR_IS_NOTIFICATION_SERVICE( notification_service ), NULL ); + + FoobarPanelItemStatus* self = g_object_new( FOOBAR_TYPE_PANEL_ITEM_STATUS, NULL ); + self->action = foobar_panel_item_configuration_get_action( config ); + self->battery_service = g_object_ref( battery_service ); + self->brightness_service = g_object_ref( brightness_service ); + self->audio_service = g_object_ref( audio_service ); + self->network_service = g_object_ref( network_service ); + self->bluetooth_service = g_object_ref( bluetooth_service ); + self->notification_service = g_object_ref( notification_service ); + + gtk_widget_set_sensitive( self->button, self->action != FOOBAR_PANEL_ITEM_ACTION_NONE ); + + gtk_box_set_spacing( GTK_BOX( self->layout ), foobar_panel_item_status_configuration_get_spacing( config ) ); + gboolean show_labels = foobar_panel_item_status_configuration_get_show_labels( config ); + gboolean enable_scrolling = foobar_panel_item_status_configuration_get_enable_scrolling( config ); + gsize items_count; + FoobarStatusItem const* items = foobar_panel_item_status_configuration_get_items( config, &items_count ); + for ( gsize i = 0; i < items_count; ++i ) + { + GtkWidget* widget = foobar_panel_item_status_create_item( self, items[i], show_labels, enable_scrolling ); + if ( widget ) + { + gtk_widget_set_halign( widget, GTK_ALIGN_CENTER ); + gtk_box_append( GTK_BOX( self->layout ), widget ); + } + } + + return FOOBAR_PANEL_ITEM( self ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Signal Handlers +// --------------------------------------------------------------------------------------------------------------------- + +// +// Called when the wi-fi adapter's active network changes. +// +// This is used to then subscribe to changes to the active network's strength. Unfortunately, we can't just use +// GtkExpressions here because the active network may be NULL in which case the strength expression would fail. If one +// expression fails to evaluate, then the closure expression used to derive the network icon/label also does not get +// updated. +// +// In addition, this method also updates the network label to show the active network's name or become invisible. +// +void foobar_panel_item_status_handle_network_change( + FoobarNetworkAdapterWifi* adapter, + GParamSpec* pspec, + gpointer userdata ) +{ + (void)pspec; + FoobarPanelItemStatus* self = (FoobarPanelItemStatus*)userdata; + + FoobarNetwork* network = foobar_network_adapter_wifi_get_active( adapter ); + if ( self->network != network ) + { + g_clear_signal_handler( &self->network_strength_handler_id, self->network ); + g_clear_object( &self->network ); + + if ( network ) + { + self->network = g_object_ref( network ); + self->network_strength_handler_id = g_signal_connect( + self->network, + "notify::strength", + G_CALLBACK( foobar_panel_item_status_handle_network_strength_change ), + self ); + } + + if ( self->network_label ) + { + gtk_label_set_label( + GTK_LABEL( self->network_label ), self->network ? foobar_network_get_name( self->network ) : NULL ); + gtk_widget_set_visible( GTK_WIDGET( self->network_label ), self->network != NULL ); + } + + foobar_panel_item_status_reevaluate_network( self ); + } +} + +// +// Called when the wi-fi adapter's active network strength changes. +// +// This just forces re-evaluation of the network icon expression for reasons mentioned in +// foobar_panel_item_status_handle_network_change. +// +void foobar_panel_item_status_handle_network_strength_change( + GObject* object, + GParamSpec* pspec, + gpointer userdata ) +{ + (void)object; + (void)pspec; + FoobarPanelItemStatus* self = (FoobarPanelItemStatus*)userdata; + foobar_panel_item_status_reevaluate_network( self ); +} + +// +// Called when the button was clicked. +// +void foobar_panel_item_status_handle_clicked( + GtkButton* button, + gpointer userdata ) +{ + (void)button; + FoobarPanelItemStatus* self = (FoobarPanelItemStatus*)userdata; + + foobar_panel_item_invoke_action( FOOBAR_PANEL_ITEM( self ), self->action ); +} + +// +// Called when the user has scrolled over the brightness item, used to adjust the brightness level. +// +gboolean foobar_panel_item_status_handle_brightness_scroll( + GtkEventControllerScroll* controller, + gdouble dx, + gdouble dy, + gpointer userdata ) +{ + (void)controller; + (void)dx; + FoobarPanelItemStatus* self = (FoobarPanelItemStatus*)userdata; + + gint new_brightness = foobar_brightness_service_get_percentage( self->brightness_service ) + (gint)dy; + foobar_brightness_service_set_percentage( self->brightness_service, new_brightness ); + + return TRUE; +} + +// +// Called when the user has scrolled over the audio item, used to adjust the volume. +// +gboolean foobar_panel_item_status_handle_audio_scroll( + GtkEventControllerScroll* controller, + gdouble dx, + gdouble dy, + gpointer userdata ) +{ + (void)controller; + (void)dx; + FoobarPanelItemStatus* self = (FoobarPanelItemStatus*)userdata; + + FoobarAudioDevice* device = foobar_audio_service_get_default_output( self->audio_service ); + gint new_volume = foobar_audio_device_get_volume( device ) + (gint)dy; + foobar_audio_device_set_volume( device, new_volume ); + + return TRUE; +} + +// --------------------------------------------------------------------------------------------------------------------- +// Value Converters +// --------------------------------------------------------------------------------------------------------------------- + +// +// Derive the network icon from the active network adapter and its state. +// +// In addition, this also uses the wi-fi adapter's active network strength which is monitored separately (see +// foobar_panel_item_status_handle_network_change). +// +gchar* foobar_panel_item_status_compute_network_icon( + GtkExpression* expression, + FoobarNetworkAdapter* adapter, + FoobarNetworkAdapterState state, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + if ( FOOBAR_IS_NETWORK_ADAPTER_WIFI( adapter ) ) + { + if ( state == FOOBAR_NETWORK_ADAPTER_STATE_DISCONNECTED ) { return g_strdup( "fluent-wifi-off-symbolic" ); } + if ( state != FOOBAR_NETWORK_ADAPTER_STATE_CONNECTED ) { return g_strdup( "fluent-wifi-warning-symbolic" ); } + + FoobarNetwork* network = foobar_network_adapter_wifi_get_active( FOOBAR_NETWORK_ADAPTER_WIFI( adapter ) ); + gint strength = network ? foobar_network_get_strength( network ) : 0; + if ( strength <= 25 ) { return g_strdup( "fluent-wifi-4-symbolic" ); } + if ( strength <= 50 ) { return g_strdup( "fluent-wifi-3-symbolic" ); } + if ( strength <= 75 ) { return g_strdup( "fluent-wifi-2-symbolic" ); } + return g_strdup( "fluent-wifi-1-symbolic" ); + } + else + { + return g_strdup( "fluent-virtual-network-symbolic" ); + } +} + +// +// Derive the bluetooth icon from the bluetooth adapter's state and the number of currently connected devices. +// +gchar* foobar_panel_item_status_compute_bluetooth_icon( + GtkExpression* expression, + gboolean is_enabled, + guint connected_device_count, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + if (is_enabled) + { + return ( connected_device_count > 0 ) + ? g_strdup( "fluent-bluetooth-connected-symbolic" ) + : g_strdup( "fluent-bluetooth-symbolic" ); + } + else + { + return g_strdup( "fluent-bluetooth-off-symbolic" ); + } +} + +// +// Derive the battery icon from the current state structure. +// +gchar* foobar_panel_item_status_compute_battery_icon( + GtkExpression* expression, + FoobarBatteryState const* state, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + if ( state ) + { + gint percentage = foobar_battery_state_get_percentage( state ); + if ( foobar_battery_state_is_charging( state ) ) { return g_strdup( "fluent-battery-charge-symbolic" ); } + if ( percentage <= 5 ) { return g_strdup( "fluent-battery-0-symbolic" ); } + if ( percentage <= 15 ) { return g_strdup( "fluent-battery-1-symbolic" ); } + if ( percentage <= 25 ) { return g_strdup( "fluent-battery-2-symbolic" ); } + if ( percentage <= 35 ) { return g_strdup( "fluent-battery-3-symbolic" ); } + if ( percentage <= 45 ) { return g_strdup( "fluent-battery-4-symbolic" ); } + if ( percentage <= 55 ) { return g_strdup( "fluent-battery-5-symbolic" ); } + if ( percentage <= 65 ) { return g_strdup( "fluent-battery-6-symbolic" ); } + if ( percentage <= 75 ) { return g_strdup( "fluent-battery-7-symbolic" ); } + if ( percentage <= 85 ) { return g_strdup( "fluent-battery-8-symbolic" ); } + if ( percentage <= 95 ) { return g_strdup( "fluent-battery-9-symbolic" ); } + return g_strdup( "fluent-battery-10-symbolic" ); + } + else + { + return g_strdup( "fluent-plug-connected-symbolic" ); + } +} + +// +// Derive the battery label from the current state structure, showing the percentage if available. +// +gchar* foobar_panel_item_status_compute_battery_label( + GtkExpression* expression, + FoobarBatteryState const* state, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + if ( state ) + { + return g_strdup_printf( "%d%%", foobar_battery_state_get_percentage( state ) ); + } + else + { + return g_strdup( "n/a" ); + } +} + +// +// Derive the brightness icon from the current percentage value. +// +gchar* foobar_panel_item_status_compute_brightness_icon( + GtkExpression* expression, + gint percentage, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + if ( percentage <= 50 ) + { + return g_strdup( "fluent-brightness-low-symbolic" ); + } + else + { + return g_strdup( "fluent-brightness-high-symbolic" ); + } +} + +// +// Derive the brightness label from the current percentage value. +// +gchar* foobar_panel_item_status_compute_brightness_label( + GtkExpression* expression, + gint percentage, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + return g_strdup_printf( "%d%%", percentage ); +} + +// +// Derive the audio icon from the current state and volume of the default output device. +// +gchar* foobar_panel_item_status_compute_audio_icon( + GtkExpression* expression, + gboolean is_available, + gint volume, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + if ( is_available ) + { + if ( volume == 0 ) { return g_strdup( "fluent-speaker-mute-symbolic" ); } + if ( volume <= 33 ) { return g_strdup( "fluent-speaker-0-symbolic" ); } + if ( volume <= 67 ) { return g_strdup( "fluent-speaker-1-symbolic" ); } + return g_strdup( "fluent-speaker-2-symbolic" ); + } + else + { + return g_strdup( "fluent-speaker-off-symbolic" ); + } +} + +// +// Derive the audio label from the current state and volume of the default output device. +// +gchar* foobar_panel_item_status_compute_audio_label( + GtkExpression* expression, + gboolean is_available, + gint volume, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + if ( is_available ) + { + return g_strdup_printf( "%d%%", volume ); + } + else + { + return g_strdup( "n/a" ); + } +} + +// +// Derive the notification icon from the current number of notifications. +// +gchar* foobar_panel_item_status_compute_notifications_icon( + GtkExpression* expression, + guint count, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + switch ( count ) + { + case 0: + return g_strdup( "fluent-checkmark-circle-symbolic" ); + case 1: + return g_strdup( "fluent-number-circle-1-symbolic" ); + case 2: + return g_strdup( "fluent-number-circle-2-symbolic" ); + case 3: + return g_strdup( "fluent-number-circle-3-symbolic" ); + case 4: + return g_strdup( "fluent-number-circle-4-symbolic" ); + case 5: + return g_strdup( "fluent-number-circle-5-symbolic" ); + case 6: + return g_strdup( "fluent-number-circle-6-symbolic" ); + case 7: + return g_strdup( "fluent-number-circle-7-symbolic" ); + case 8: + return g_strdup( "fluent-number-circle-8-symbolic" ); + case 9: + return g_strdup( "fluent-number-circle-9-symbolic" ); + default: + return g_strdup( "fluent-more-circle-symbolic" ); + } +} + +// --------------------------------------------------------------------------------------------------------------------- +// Helper Methods +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new icon displaying the specified status item, optionally adding a label to it (if supported). +// +GtkWidget* foobar_panel_item_status_create_item( + FoobarPanelItemStatus* self, + FoobarStatusItem item, + gboolean show_labels, + gboolean enable_scrolling ) +{ + switch ( item ) + { + case FOOBAR_STATUS_ITEM_NETWORK: + { + GtkWidget* box = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ); + gtk_widget_set_valign( box, GTK_ALIGN_FILL ); + + GtkExpression* service_expr = gtk_constant_expression_new( + FOOBAR_TYPE_NETWORK_SERVICE, + self->network_service ); + GtkExpression* active_expr = gtk_property_expression_new( + FOOBAR_TYPE_NETWORK_SERVICE, + service_expr, + "active" ); + GtkExpression* state_expr = gtk_property_expression_new( + FOOBAR_TYPE_NETWORK_ADAPTER, + gtk_expression_ref( active_expr ), + "state" ); + GtkExpression* icon_params[] = { active_expr, state_expr }; + self->network_icon_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( icon_params ), + icon_params, + G_CALLBACK( foobar_panel_item_status_compute_network_icon ), + self, + NULL ); + self->network_icon = gtk_image_new( ); + gtk_widget_set_valign( self->network_icon, GTK_ALIGN_CENTER ); + gtk_expression_bind( gtk_expression_ref( self->network_icon_expr ), self->network_icon, "icon-name", NULL ); + gtk_box_append( GTK_BOX( box ), self->network_icon ); + + if ( show_labels ) + { + self->network_label = gtk_label_new( NULL ); + gtk_widget_set_valign( self->network_label, GTK_ALIGN_CENTER ); + gtk_label_set_max_width_chars( GTK_LABEL( self->network_label ), 16 ); + gtk_label_set_ellipsize( GTK_LABEL( self->network_label ), PANGO_ELLIPSIZE_END ); + gtk_box_append( GTK_BOX( box ), self->network_label ); + } + + // Manually subscribe to network (/strength) because evaluation might fail. + + FoobarNetworkAdapterWifi* adapter = foobar_network_service_get_wifi( self->network_service ); + if ( adapter ) + { + self->network_handler_id = g_signal_connect( + adapter, + "notify::active", + G_CALLBACK( foobar_panel_item_status_handle_network_change ), + self ); + if ( foobar_network_adapter_wifi_get_active( adapter ) ) + { + self->network = g_object_ref( foobar_network_adapter_wifi_get_active( adapter ) ); + self->network_strength_handler_id = g_signal_connect( + self->network, + "notify::strength", + G_CALLBACK( foobar_panel_item_status_handle_network_strength_change ), + self ); + } + if ( self->network_label ) + { + gtk_label_set_label( + GTK_LABEL( self->network_label ), + self->network ? foobar_network_get_name( self->network ) : NULL ); + gtk_widget_set_visible( GTK_WIDGET( self->network_label ), self->network != NULL ); + } + } + + return box; + } + case FOOBAR_STATUS_ITEM_BLUETOOTH: + { + GtkWidget* icon = gtk_image_new( ); + gtk_widget_set_valign( icon, GTK_ALIGN_CENTER ); + + GtkExpression* service_expr = gtk_constant_expression_new( + FOOBAR_TYPE_BLUETOOTH_SERVICE, + self->bluetooth_service ); + GtkExpression* enabled_expr = gtk_property_expression_new( + FOOBAR_TYPE_BLUETOOTH_SERVICE, + gtk_expression_ref( service_expr ), + "is-enabled" ); + GtkExpression* connected_devices_expr = gtk_property_expression_new( + FOOBAR_TYPE_BLUETOOTH_SERVICE, + service_expr, + "connected-devices" ); + GtkExpression* connected_device_count_expr = gtk_property_expression_new( + GTK_TYPE_FILTER_LIST_MODEL, + connected_devices_expr, + "n-items" ); + GtkExpression* icon_params[] = { enabled_expr, connected_device_count_expr }; + GtkExpression* icon_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( icon_params ), + icon_params, + G_CALLBACK( foobar_panel_item_status_compute_bluetooth_icon ), + NULL, + NULL ); + gtk_expression_bind( icon_expr, icon, "icon-name", NULL ); + + return icon; + } + case FOOBAR_STATUS_ITEM_BATTERY: + { + GtkWidget* box = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ); + gtk_widget_set_valign( box, GTK_ALIGN_FILL ); + + GtkExpression* service_expr = gtk_constant_expression_new( + FOOBAR_TYPE_BATTERY_SERVICE, + self->battery_service ); + GtkExpression* state_expr = gtk_property_expression_new( + FOOBAR_TYPE_BATTERY_SERVICE, + service_expr, + "state" ); + + GtkExpression* icon_params[] = { state_expr }; + GtkExpression* icon_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( icon_params ), + icon_params, + G_CALLBACK( foobar_panel_item_status_compute_battery_icon ), + NULL, + NULL ); + GtkWidget* icon = gtk_image_new( ); + gtk_widget_set_valign( icon, GTK_ALIGN_CENTER ); + gtk_expression_bind( icon_expr, icon, "icon-name", NULL ); + gtk_box_append( GTK_BOX( box ), icon ); + + if ( show_labels ) + { + GtkExpression* label_params[] = { gtk_expression_ref( state_expr ) }; + GtkExpression* label_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( label_params ), + label_params, + G_CALLBACK( foobar_panel_item_status_compute_battery_label ), + NULL, + NULL ); + GtkWidget* label = gtk_label_new( NULL ); + gtk_widget_set_valign( label, GTK_ALIGN_CENTER ); + gtk_expression_bind( label_expr, label, "label", NULL ); + gtk_box_append( GTK_BOX( box ), label ); + } + + return box; + } + case FOOBAR_STATUS_ITEM_BRIGHTNESS: + { + GtkWidget* box = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ); + gtk_widget_set_valign( box, GTK_ALIGN_FILL ); + + if ( enable_scrolling ) + { + GtkEventController* scroll_controller = gtk_event_controller_scroll_new( + GTK_EVENT_CONTROLLER_SCROLL_VERTICAL | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE ); + g_signal_connect( + scroll_controller, + "scroll", + G_CALLBACK( foobar_panel_item_status_handle_brightness_scroll ), + self ); + gtk_widget_add_controller( box, scroll_controller ); + } + + GtkExpression* service_expr = gtk_constant_expression_new( + FOOBAR_TYPE_BRIGHTNESS_SERVICE, + self->brightness_service ); + GtkExpression* percentage_expr = gtk_property_expression_new( + FOOBAR_TYPE_BRIGHTNESS_SERVICE, + service_expr, + "percentage" ); + + GtkExpression* icon_params[] = { percentage_expr }; + GtkExpression* icon_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( icon_params ), + icon_params, + G_CALLBACK( foobar_panel_item_status_compute_brightness_icon ), + NULL, + NULL ); + GtkWidget* icon = gtk_image_new( ); + gtk_widget_set_valign( icon, GTK_ALIGN_CENTER ); + gtk_expression_bind( icon_expr, icon, "icon-name", NULL ); + gtk_box_append( GTK_BOX( box ), icon ); + + if ( show_labels ) + { + GtkExpression* label_params[] = { gtk_expression_ref( percentage_expr ) }; + GtkExpression* label_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( label_params ), + label_params, + G_CALLBACK( foobar_panel_item_status_compute_brightness_label ), + NULL, + NULL ); + GtkWidget* label = gtk_label_new( NULL ); + gtk_widget_set_valign( label, GTK_ALIGN_CENTER ); + gtk_expression_bind( label_expr, label, "label", NULL ); + gtk_box_append( GTK_BOX( box ), label ); + } + + return box; + } + case FOOBAR_STATUS_ITEM_AUDIO: + { + GtkWidget* box = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ); + gtk_widget_set_valign( box, GTK_ALIGN_FILL ); + + if ( enable_scrolling ) + { + GtkEventController* scroll_controller = gtk_event_controller_scroll_new( + GTK_EVENT_CONTROLLER_SCROLL_VERTICAL | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE ); + g_signal_connect( + scroll_controller, + "scroll", + G_CALLBACK( foobar_panel_item_status_handle_audio_scroll ), + self ); + gtk_widget_add_controller( box, scroll_controller ); + } + + GtkExpression* device_expr = gtk_constant_expression_new( + FOOBAR_TYPE_AUDIO_DEVICE, + foobar_audio_service_get_default_output( self->audio_service ) ); + GtkExpression* available_expr = gtk_property_expression_new( + FOOBAR_TYPE_AUDIO_DEVICE, + gtk_expression_ref( device_expr ), + "is-available" ); + GtkExpression* volume_expr = gtk_property_expression_new( + FOOBAR_TYPE_AUDIO_DEVICE, + gtk_expression_ref( device_expr ), + "volume" ); + + GtkExpression* icon_params[] = { available_expr, volume_expr }; + GtkExpression* icon_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( icon_params ), + icon_params, + G_CALLBACK( foobar_panel_item_status_compute_audio_icon ), + NULL, + NULL ); + GtkWidget* icon = gtk_image_new( ); + gtk_widget_set_valign( icon, GTK_ALIGN_CENTER ); + gtk_expression_bind( icon_expr, icon, "icon-name", NULL ); + gtk_box_append( GTK_BOX( box ), icon ); + + if ( show_labels ) + { + GtkExpression* label_params[] = { gtk_expression_ref( available_expr ), gtk_expression_ref( volume_expr ) }; + GtkExpression* label_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( label_params ), + label_params, + G_CALLBACK( foobar_panel_item_status_compute_audio_label ), + NULL, + NULL ); + GtkWidget* label = gtk_label_new( NULL ); + gtk_widget_set_valign( label, GTK_ALIGN_CENTER ); + gtk_expression_bind( label_expr, label, "label", NULL ); + gtk_box_append( GTK_BOX( box ), label ); + } + + return box; + } + case FOOBAR_STATUS_ITEM_NOTIFICATIONS: + { + GtkWidget* icon = gtk_image_new( ); + gtk_widget_set_valign( icon, GTK_ALIGN_CENTER ); + + GtkExpression* list_expr = gtk_constant_expression_new( + G_TYPE_LIST_MODEL, + foobar_notification_service_get_notifications( self->notification_service ) ); + GtkExpression* count_expr = gtk_property_expression_new( + GTK_TYPE_SORT_LIST_MODEL, + list_expr, + "n-items" ); + GtkExpression* icon_params[] = { count_expr }; + GtkExpression* icon_expr = gtk_cclosure_expression_new( + G_TYPE_STRING, + NULL, + G_N_ELEMENTS( icon_params ), + icon_params, + G_CALLBACK( foobar_panel_item_status_compute_notifications_icon ), + NULL, + NULL ); + gtk_expression_bind( icon_expr, icon, "icon-name", NULL ); + + return icon; + } + default: + g_warn_if_reached( ); + return NULL; + } +} + +// +// Force re-evaluation of the network icon expression. +// +// This is used whenever the active network or its strength changes. +// +void foobar_panel_item_status_reevaluate_network( FoobarPanelItemStatus* self ) +{ + if ( self->network_icon && self->network_icon_expr ) + { + GValue value = G_VALUE_INIT; + if ( gtk_expression_evaluate( self->network_icon_expr, NULL, &value ) ) + { + gtk_image_set_from_icon_name( GTK_IMAGE( self->network_icon ), g_value_get_string( &value ) ); + } + g_value_unset( &value ); + } +}
\ No newline at end of file diff --git a/src/widgets/panel/panel-item-status.h b/src/widgets/panel/panel-item-status.h new file mode 100644 index 0000000..e18c097 --- /dev/null +++ b/src/widgets/panel/panel-item-status.h @@ -0,0 +1,25 @@ +#pragma once + +#include "widgets/panel/panel-item.h" +#include "services/battery-service.h" +#include "services/brightness-service.h" +#include "services/audio-service.h" +#include "services/network-service.h" +#include "services/bluetooth-service.h" +#include "services/notification-service.h" + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_PANEL_ITEM_STATUS foobar_panel_item_status_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarPanelItemStatus, foobar_panel_item_status, FOOBAR, PANEL_ITEM_STATUS, FoobarPanelItem ) + +FoobarPanelItem* foobar_panel_item_status_new( FoobarPanelItemConfiguration const* config, + FoobarBatteryService* battery_service, + FoobarBrightnessService* brightness_service, + FoobarAudioService* audio_service, + FoobarNetworkService* network_service, + FoobarBluetoothService* bluetooth_service, + FoobarNotificationService* notification_service ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/panel/panel-item-workspaces.c b/src/widgets/panel/panel-item-workspaces.c new file mode 100644 index 0000000..acdd201 --- /dev/null +++ b/src/widgets/panel/panel-item-workspaces.c @@ -0,0 +1,327 @@ +#include "widgets/panel/panel-item-workspaces.h" +#include "widgets/inset-container.h" + +// +// FoobarPanelItemWorkspaces: +// +// A panel item showing all workspaces for the current monitor (if multi-monitor mode is enabled) as buttons, indicating +// the current state of the workspace (i.e., whether it's active, visible, special, etc.). +// + +struct _FoobarPanelItemWorkspaces +{ + FoobarPanelItem parent_instance; + GtkWidget* list_view; + GtkWidget* inset_container; + FoobarWorkspaceService* workspace_service; + gint button_size; + gint spacing; + GtkFilter* monitor_filter; + gulong monitor_configuration_handler_id; +}; + +enum +{ + PROP_ORIENTATION = 1, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_panel_item_workspaces_class_init ( FoobarPanelItemWorkspacesClass* klass ); +static void foobar_panel_item_workspaces_init ( FoobarPanelItemWorkspaces* self ); +static void foobar_panel_item_workspaces_get_property ( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_panel_item_workspaces_set_property ( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_panel_item_workspaces_finalize ( GObject* object ); +static void foobar_panel_item_workspaces_handle_item_setup ( GtkListItemFactory* factory, + GtkListItem* list_item, + gpointer userdata ); +static void foobar_panel_item_workspaces_handle_item_clicked ( GtkButton* button, + gpointer userdata ); +static void foobar_panel_item_workspaces_handle_monitor_configuration_changed( FoobarWorkspaceService* service, + gpointer userdata ); +static gchar** foobar_panel_item_workspaces_compute_css_classes ( GtkExpression* expression, + FoobarWorkspaceFlags flags, + gpointer userdata ); +static gboolean foobar_panel_item_workspaces_monitor_filter_func ( gpointer item, + gpointer userdata ); + +G_DEFINE_FINAL_TYPE_WITH_CODE( + FoobarPanelItemWorkspaces, + foobar_panel_item_workspaces, + FOOBAR_TYPE_PANEL_ITEM, + G_IMPLEMENT_INTERFACE( GTK_TYPE_ORIENTABLE, NULL ) ) + +// --------------------------------------------------------------------------------------------------------------------- +// Panel Item Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for workspace panel items. +// +void foobar_panel_item_workspaces_class_init( FoobarPanelItemWorkspacesClass* klass ) +{ + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_panel_item_workspaces_get_property; + object_klass->set_property = foobar_panel_item_workspaces_set_property; + object_klass->finalize = foobar_panel_item_workspaces_finalize; + + gpointer orientable_iface = g_type_default_interface_peek( GTK_TYPE_ORIENTABLE ); + props[PROP_ORIENTATION] = g_param_spec_override( + "orientation", + g_object_interface_find_property( orientable_iface, "orientation" ) ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for workspace panel items. +// +void foobar_panel_item_workspaces_init( FoobarPanelItemWorkspaces* self ) +{ + GtkListItemFactory* item_factory = gtk_signal_list_item_factory_new( ); + g_signal_connect( item_factory, "setup", G_CALLBACK( foobar_panel_item_workspaces_handle_item_setup ), self ); + + self->list_view = gtk_list_view_new( NULL, item_factory ); + gtk_widget_set_halign( self->list_view, GTK_ALIGN_CENTER ); + gtk_widget_set_valign( self->list_view, GTK_ALIGN_CENTER ); + gtk_list_view_set_single_click_activate( GTK_LIST_VIEW( self->list_view ), TRUE ); + + self->inset_container = foobar_inset_container_new( ); + foobar_inset_container_set_child( FOOBAR_INSET_CONTAINER( self->inset_container ), GTK_WIDGET( self->list_view ) ); + + gtk_widget_add_css_class( GTK_WIDGET( self ), "workspaces" ); + foobar_panel_item_set_child( FOOBAR_PANEL_ITEM( self ), GTK_WIDGET( self->inset_container ) ); +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_panel_item_workspaces_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarPanelItemWorkspaces* self = (FoobarPanelItemWorkspaces*)object; + + switch ( prop_id ) + { + case PROP_ORIENTATION: + g_value_set_enum( value, gtk_orientable_get_orientation( GTK_ORIENTABLE( self->list_view ) ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_panel_item_workspaces_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarPanelItemWorkspaces* self = (FoobarPanelItemWorkspaces*)object; + + switch ( prop_id ) + { + case PROP_ORIENTATION: + gtk_orientable_set_orientation( GTK_ORIENTABLE( self->list_view ), g_value_get_enum( value ) ); + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_ORIENTATION] ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance cleanup for workspace panel items. +// +void foobar_panel_item_workspaces_finalize( GObject* object ) +{ + FoobarPanelItemWorkspaces* self = (FoobarPanelItemWorkspaces*)object; + + g_clear_signal_handler( &self->monitor_configuration_handler_id, self->workspace_service ); + g_clear_object( &self->workspace_service ); + g_clear_object( &self->monitor_filter ); + + G_OBJECT_CLASS( foobar_panel_item_workspaces_parent_class )->finalize( object ); +} + + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Create a new workspaces panel item with the given configuration. +// +// If monitor is not NULL, only workspaces on this monitor will be shown. +// +FoobarPanelItem* foobar_panel_item_workspaces_new( + FoobarPanelItemConfiguration const* config, + GdkMonitor* monitor, + FoobarWorkspaceService* workspace_service ) +{ + g_return_val_if_fail( config != NULL, NULL ); + g_return_val_if_fail( foobar_panel_item_configuration_get_kind( config ) == FOOBAR_PANEL_ITEM_KIND_WORKSPACES, NULL ); + g_return_val_if_fail( monitor == NULL || GDK_IS_MONITOR( monitor ), NULL ); + g_return_val_if_fail( FOOBAR_IS_WORKSPACE_SERVICE( workspace_service ), NULL ); + + FoobarPanelItemWorkspaces* self = g_object_new( FOOBAR_TYPE_PANEL_ITEM_WORKSPACES, NULL ); + self->button_size = foobar_panel_item_workspaces_configuration_get_button_size( config ); + self->spacing = foobar_panel_item_workspaces_configuration_get_spacing( config ); + self->workspace_service = g_object_ref( workspace_service ); + + // Set up the source model, optionally enabling filtering. + + GListModel* source_model = g_object_ref( foobar_workspace_service_get_workspaces( self->workspace_service ) ); + if ( monitor ) + { + GtkCustomFilter* filter = gtk_custom_filter_new( + foobar_panel_item_workspaces_monitor_filter_func, + g_object_ref( monitor ), + g_object_unref ); + self->monitor_filter = GTK_FILTER( filter ); + source_model = G_LIST_MODEL( gtk_filter_list_model_new( source_model, g_object_ref( self->monitor_filter ) ) ); + + self->monitor_configuration_handler_id = g_signal_connect( + self->workspace_service, + "monitor-configuration-changed", + G_CALLBACK( foobar_panel_item_workspaces_handle_monitor_configuration_changed ), + self ); + } + GtkNoSelection* selection_model = gtk_no_selection_new( source_model ); + gtk_list_view_set_model( GTK_LIST_VIEW( self->list_view ), GTK_SELECTION_MODEL( selection_model ) ); + + // Wrap the list in an inset container to remove the outer margin from the items. + + foobar_inset_container_set_inset_horizontal( FOOBAR_INSET_CONTAINER( self->inset_container ), -self->spacing / 2 ); + foobar_inset_container_set_inset_vertical( FOOBAR_INSET_CONTAINER( self->inset_container ), -self->spacing / 2 ); + + return FOOBAR_PANEL_ITEM( self ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Signal Handlers +// --------------------------------------------------------------------------------------------------------------------- + +// +// Called by the list view to create a widget for displaying a workspace. +// +void foobar_panel_item_workspaces_handle_item_setup( + GtkListItemFactory* factory, + GtkListItem* list_item, + gpointer userdata ) +{ + (void)factory; + FoobarPanelItemWorkspaces* self = (FoobarPanelItemWorkspaces*)userdata; + + GtkWidget* button = gtk_button_new( ); + gtk_widget_set_size_request( button, self->button_size, self->button_size ); + gtk_widget_set_margin_top( button, self->spacing / 2 ); + gtk_widget_set_margin_bottom( button, self->spacing / 2 ); + gtk_widget_set_margin_start( button, self->spacing / 2 ); + gtk_widget_set_margin_end( button, self->spacing / 2 ); + g_signal_connect( + button, + "clicked", + G_CALLBACK( foobar_panel_item_workspaces_handle_item_clicked ), + list_item ); + + gtk_list_item_set_child( list_item, button ); + + { + GtkExpression* item_expr = gtk_property_expression_new( GTK_TYPE_LIST_ITEM, NULL, "item" ); + GtkExpression* active_expr = gtk_property_expression_new( FOOBAR_TYPE_WORKSPACE, item_expr, "flags" ); + GtkExpression* params[] = { active_expr }; + GtkExpression* css_expr = gtk_cclosure_expression_new( + G_TYPE_STRV, + NULL, + G_N_ELEMENTS( params ), + params, + G_CALLBACK( foobar_panel_item_workspaces_compute_css_classes ), + NULL, + NULL ); + gtk_expression_bind( css_expr, button, "css-classes", list_item ); + } +} + +// +// Called by the workspace service when the monitor for any workspace has changed. +// +// This is needed because the GtkFilterListModel does not track changes to the item properties and needs to be +// re-evaluated manually. +// +void foobar_panel_item_workspaces_handle_monitor_configuration_changed( + FoobarWorkspaceService* service, + gpointer userdata ) +{ + (void)service; + FoobarPanelItemWorkspaces* self = (FoobarPanelItemWorkspaces*)userdata; + + gtk_filter_changed( self->monitor_filter, GTK_FILTER_CHANGE_DIFFERENT ); +} + +// +// Called when a workspace button was clicked, activating that workspace. +// +void foobar_panel_item_workspaces_handle_item_clicked( GtkButton* button, gpointer userdata ) +{ + (void)button; + GtkListItem* item = (GtkListItem*)userdata; + + FoobarWorkspace* workspace = gtk_list_item_get_item( item ); + if ( workspace ) { foobar_workspace_activate( workspace ); } +} + +// --------------------------------------------------------------------------------------------------------------------- +// Value Converters +// --------------------------------------------------------------------------------------------------------------------- + +// +// Derive the list of CSS classes for a workspace button from the workspace's current flags. +// +gchar** foobar_panel_item_workspaces_compute_css_classes( + GtkExpression* expression, + FoobarWorkspaceFlags flags, + gpointer userdata ) +{ + (void)expression; + (void)userdata; + + GStrvBuilder* builder = g_strv_builder_new( ); + if ( flags & FOOBAR_WORKSPACE_FLAGS_ACTIVE ) { g_strv_builder_add( builder, "active" ); } + if ( flags & FOOBAR_WORKSPACE_FLAGS_VISIBLE ) { g_strv_builder_add( builder, "visible" ); } + if ( flags & FOOBAR_WORKSPACE_FLAGS_SPECIAL ) { g_strv_builder_add( builder, "special" ); } + if ( flags & FOOBAR_WORKSPACE_FLAGS_URGENT ) { g_strv_builder_add( builder, "urgent" ); } + if ( flags & FOOBAR_WORKSPACE_FLAGS_PERSISTENT ) { g_strv_builder_add( builder, "persistent" ); } + return g_strv_builder_end( builder ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Helper Methods +// --------------------------------------------------------------------------------------------------------------------- + +// +// Check if a workspace is on the panel's monitor. +// +gboolean foobar_panel_item_workspaces_monitor_filter_func( gpointer item, gpointer userdata ) +{ + FoobarWorkspace* workspace = (FoobarWorkspace*)item; + GdkMonitor* monitor = (GdkMonitor*)userdata; + + gchar const* expected = gdk_monitor_get_connector( monitor ); + gchar const* actual = foobar_workspace_get_monitor( workspace ); + return !expected || !g_strcmp0( expected, actual ); +}
\ No newline at end of file diff --git a/src/widgets/panel/panel-item-workspaces.h b/src/widgets/panel/panel-item-workspaces.h new file mode 100644 index 0000000..c9d7ef1 --- /dev/null +++ b/src/widgets/panel/panel-item-workspaces.h @@ -0,0 +1,16 @@ +#pragma once + +#include "widgets/panel/panel-item.h" +#include "services/workspace-service.h" + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_PANEL_ITEM_WORKSPACES foobar_panel_item_workspaces_get_type( ) + +G_DECLARE_FINAL_TYPE( FoobarPanelItemWorkspaces, foobar_panel_item_workspaces, FOOBAR, PANEL_ITEM_WORKSPACES, FoobarPanelItem ) + +FoobarPanelItem* foobar_panel_item_workspaces_new( FoobarPanelItemConfiguration const* config, + GdkMonitor* monitor, + FoobarWorkspaceService* workspace_service ); + +G_END_DECLS
\ No newline at end of file diff --git a/src/widgets/panel/panel-item.c b/src/widgets/panel/panel-item.c new file mode 100644 index 0000000..f2d4383 --- /dev/null +++ b/src/widgets/panel/panel-item.c @@ -0,0 +1,195 @@ +#include "widgets/panel/panel-item.h" +#include "application.h" + +// +// FoobarPanelItem: +// +// Base class for all panel items. This is basically a bin layout where the subclass usually sets the child widget. +// + +typedef struct _FoobarPanelItemPrivate +{ + GtkWidget* child; +} FoobarPanelItemPrivate; + +enum +{ + PROP_CHILD = 1, + N_PROPS, +}; + +static GParamSpec* props[N_PROPS] = { 0 }; + +static void foobar_panel_item_class_init ( FoobarPanelItemClass* klass ); +static void foobar_panel_item_init ( FoobarPanelItem* self ); +static void foobar_panel_item_get_property( GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ); +static void foobar_panel_item_set_property( GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ); +static void foobar_panel_item_dispose ( GObject* object ); + +G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE( FoobarPanelItem, foobar_panel_item, GTK_TYPE_WIDGET ) + +// --------------------------------------------------------------------------------------------------------------------- +// Widget Implementation +// --------------------------------------------------------------------------------------------------------------------- + +// +// Static initialization for panel items. +// +void foobar_panel_item_class_init( FoobarPanelItemClass* klass ) +{ + GtkWidgetClass* widget_klass = GTK_WIDGET_CLASS( klass ); + gtk_widget_class_set_css_name( widget_klass, "panel-item" ); + gtk_widget_class_set_layout_manager_type( widget_klass, GTK_TYPE_BIN_LAYOUT ); + + GObjectClass* object_klass = G_OBJECT_CLASS( klass ); + object_klass->get_property = foobar_panel_item_get_property; + object_klass->set_property = foobar_panel_item_set_property; + object_klass->dispose = foobar_panel_item_dispose; + + props[PROP_CHILD] = g_param_spec_object( + "child", + "Child", + "Child widget for the panel item.", + GTK_TYPE_WIDGET, + G_PARAM_READWRITE ); + g_object_class_install_properties( object_klass, N_PROPS, props ); +} + +// +// Instance initialization for panel items. +// +void foobar_panel_item_init( FoobarPanelItem* self ) +{ + (void)self; +} + +// +// Property getter implementation, mapping a property id to a method. +// +void foobar_panel_item_get_property( + GObject* object, + guint prop_id, + GValue* value, + GParamSpec* pspec ) +{ + FoobarPanelItem* self = (FoobarPanelItem*)object; + + switch ( prop_id ) + { + case PROP_CHILD: + g_value_set_object( value, foobar_panel_item_get_child( self ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Property setter implementation, mapping a property id to a method. +// +void foobar_panel_item_set_property( + GObject* object, + guint prop_id, + GValue const* value, + GParamSpec* pspec ) +{ + FoobarPanelItem* self = (FoobarPanelItem*)object; + + switch ( prop_id ) + { + case PROP_CHILD: + foobar_panel_item_set_child( self, g_value_get_object( value ) ); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec ); + break; + } +} + +// +// Instance de-initialization for panel items. +// +void foobar_panel_item_dispose( GObject* object ) +{ + FoobarPanelItem* self = (FoobarPanelItem*)object; + FoobarPanelItemPrivate* priv = foobar_panel_item_get_instance_private( self ); + + g_clear_pointer( &priv->child, gtk_widget_unparent ); + + G_OBJECT_CLASS( foobar_panel_item_parent_class )->dispose( object ); +} + +// --------------------------------------------------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------------------------------------------------- + +// +// Get the child widget for the panel item. +// +GtkWidget* foobar_panel_item_get_child( FoobarPanelItem* self ) +{ + g_return_val_if_fail( FOOBAR_IS_PANEL_ITEM( self ), NULL ); + FoobarPanelItemPrivate* priv = foobar_panel_item_get_instance_private( self ); + + return priv->child; +} + +// +// Update the child widget for the panel item. +// +void foobar_panel_item_set_child( + FoobarPanelItem* self, + GtkWidget* child ) +{ + g_return_if_fail( FOOBAR_IS_PANEL_ITEM( self ) ); + FoobarPanelItemPrivate* priv = foobar_panel_item_get_instance_private( self ); + g_return_if_fail( child == NULL || priv->child == child || gtk_widget_get_parent( child ) == NULL ); + + if ( priv->child != child ) + { + g_clear_pointer( &priv->child, gtk_widget_unparent ); + + if ( child ) + { + priv->child = child; + gtk_widget_set_parent( child, GTK_WIDGET( self ) ); + } + + g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CHILD] ); + } +} + +// +// Invoke the action for the panel item. +// +// This needs to be triggered by a subclass, for example by adding a button to the item. Support for panel item actions +// is opt-in and subclasses have to explicitly implement it. This is just a helper for implementing the action. +// +void foobar_panel_item_invoke_action( + FoobarPanelItem* self, + FoobarPanelItemAction action ) +{ + g_return_if_fail( FOOBAR_IS_PANEL_ITEM( self ) ); + + switch ( action ) + { + case FOOBAR_PANEL_ITEM_ACTION_NONE: + break; + case FOOBAR_PANEL_ITEM_ACTION_LAUNCHER: + foobar_application_toggle_launcher( FOOBAR_APPLICATION_DEFAULT ); + break; + case FOOBAR_PANEL_ITEM_ACTION_CONTROL_CENTER: + foobar_application_toggle_control_center( FOOBAR_APPLICATION_DEFAULT ); + break; + default: + g_warn_if_reached( ); + break; + } +}
\ No newline at end of file diff --git a/src/widgets/panel/panel-item.h b/src/widgets/panel/panel-item.h new file mode 100644 index 0000000..318bd85 --- /dev/null +++ b/src/widgets/panel/panel-item.h @@ -0,0 +1,23 @@ +#pragma once + +#include <gtk/gtk.h> +#include "services/configuration-service.h" + +G_BEGIN_DECLS + +#define FOOBAR_TYPE_PANEL_ITEM foobar_panel_item_get_type( ) + +G_DECLARE_DERIVABLE_TYPE( FoobarPanelItem, foobar_panel_item, FOOBAR, PANEL_ITEM, GtkWidget ) + +struct _FoobarPanelItemClass +{ + GtkWidgetClass parent_class; +}; + +GtkWidget* foobar_panel_item_get_child ( FoobarPanelItem* self ); +void foobar_panel_item_set_child ( FoobarPanelItem* self, + GtkWidget* child ); +void foobar_panel_item_invoke_action( FoobarPanelItem* self, + FoobarPanelItemAction action ); + +G_END_DECLS
\ No newline at end of file |