diff --git a/data/new-call-symbolic.svg b/data/new-call-symbolic.svg new file mode 100644 index 0000000..945c1e8 --- /dev/null +++ b/data/new-call-symbolic.svg @@ -0,0 +1,17 @@ + + + + + + + image/svg+xml + + + + + + + + + + \ No newline at end of file diff --git a/plugins/dummy/calls-dummy-call.c b/plugins/dummy/calls-dummy-call.c index bd6bcb6..ab8146e 100644 --- a/plugins/dummy/calls-dummy-call.c +++ b/plugins/dummy/calls-dummy-call.c @@ -33,6 +33,7 @@ struct _CallsDummyCall { GObject parent_instance; gchar *number; + gboolean inbound; CallsCallState state; }; @@ -48,6 +49,8 @@ G_DEFINE_TYPE_WITH_CODE (CallsDummyCall, calls_dummy_call, G_TYPE_OBJECT, enum { PROP_0, PROP_NUMBER, + PROP_INBOUND_CONSTRUCTOR, + PROP_INBOUND, PROP_LAST_PROP, }; static GParamSpec *props[PROP_LAST_PROP]; @@ -135,16 +138,45 @@ tone_stop (CallsCall *call, gchar key) g_info ("Beep end (%c)", (int)key); } + +static gboolean +outbound_timeout_cb (CallsDummyCall *self) +{ + switch (self->state) + { + case CALLS_CALL_STATE_DIALING: + change_state (CALLS_CALL (self), self, + CALLS_CALL_STATE_ALERTING); + g_timeout_add_seconds + (3, (GSourceFunc)outbound_timeout_cb, self); + break; + + case CALLS_CALL_STATE_ALERTING: + change_state (CALLS_CALL (self), self, + CALLS_CALL_STATE_ACTIVE); + break; + + default: + break; + } + + return FALSE; +} + + CallsDummyCall * -calls_dummy_call_new (const gchar *number) +calls_dummy_call_new (const gchar *number, + gboolean inbound) { g_return_val_if_fail (number != NULL, NULL); return g_object_new (CALLS_TYPE_DUMMY_CALL, "number", number, + "inbound-constructor", inbound, NULL); } + static void set_property (GObject *object, guint property_id, @@ -158,12 +190,57 @@ set_property (GObject *object, self->number = g_value_dup_string (value); break; + case PROP_INBOUND_CONSTRUCTOR: + self->inbound = g_value_get_boolean (value); + break; + default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } + +static void +constructed (GObject *object) +{ + GObjectClass *parent_class = g_type_class_peek (G_TYPE_OBJECT); + CallsDummyCall *self = CALLS_DUMMY_CALL (object); + + if (self->inbound) + { + self->state = CALLS_CALL_STATE_INCOMING; + } + else + { + self->state = CALLS_CALL_STATE_DIALING; + g_timeout_add_seconds (1, (GSourceFunc)outbound_timeout_cb, self); + } + + parent_class->constructed (object); +} + + +static void +get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + CallsDummyCall *self = CALLS_DUMMY_CALL (object); + + switch (property_id) { + case PROP_INBOUND: + g_value_set_boolean (value, self->inbound); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + static void finalize (GObject *object) { @@ -181,8 +258,10 @@ calls_dummy_call_class_init (CallsDummyCallClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - object_class->finalize = finalize; + object_class->get_property = get_property; object_class->set_property = set_property; + object_class->constructed = constructed; + object_class->finalize = finalize; props[PROP_NUMBER] = g_param_spec_string ("number", @@ -190,8 +269,25 @@ calls_dummy_call_class_init (CallsDummyCallClass *klass) _("The dialed number"), "+441234567890", G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); + g_object_class_install_property (object_class, PROP_NUMBER, + props[PROP_NUMBER]); - g_object_class_install_properties (object_class, PROP_LAST_PROP, props); + props[PROP_INBOUND_CONSTRUCTOR] = + g_param_spec_boolean ("inbound-constructor", + _("Inbound (constructor)"), + _("Whether the calls is inbound (dummy class constructor)"), + FALSE, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); + g_object_class_install_property (object_class, PROP_INBOUND_CONSTRUCTOR, + props[PROP_INBOUND_CONSTRUCTOR]); + + props[PROP_INBOUND] = + g_param_spec_boolean ("inbound", + _("Inbound"), + _("Whether the call is inbound"), + FALSE, + G_PARAM_READABLE | G_PARAM_CONSTRUCT); + g_object_class_override_property (object_class, PROP_INBOUND, "inbound"); } static void diff --git a/plugins/dummy/calls-dummy-call.h b/plugins/dummy/calls-dummy-call.h index 8330fb5..fbf9671 100644 --- a/plugins/dummy/calls-dummy-call.h +++ b/plugins/dummy/calls-dummy-call.h @@ -33,7 +33,8 @@ G_BEGIN_DECLS G_DECLARE_FINAL_TYPE (CallsDummyCall, calls_dummy_call, CALLS, DUMMY_CALL, GObject); -CallsDummyCall *calls_dummy_call_new (const gchar *number); +CallsDummyCall *calls_dummy_call_new (const gchar *number, + gboolean inbound); G_END_DECLS diff --git a/plugins/dummy/calls-dummy-origin.c b/plugins/dummy/calls-dummy-origin.c index 9057adc..929fbd4 100644 --- a/plugins/dummy/calls-dummy-origin.c +++ b/plugins/dummy/calls-dummy-origin.c @@ -127,19 +127,13 @@ call_state_changed_cb (CallsDummyOrigin *self, static void -dial (CallsOrigin *origin, const gchar *number) +add_call (CallsDummyOrigin *self, const gchar *number, gboolean inbound) { - CallsDummyOrigin *self; CallsDummyCall *dummy_call; CallsCall *call; - g_return_if_fail (number != NULL); - g_return_if_fail (CALLS_IS_DUMMY_ORIGIN (origin)); - - self = CALLS_DUMMY_ORIGIN (origin); - - dummy_call = calls_dummy_call_new (number); - g_return_if_fail (dummy_call != NULL); + dummy_call = calls_dummy_call_new (number, inbound); + g_assert (dummy_call != NULL); call = CALLS_CALL (dummy_call); g_signal_connect_swapped (call, "state-changed", @@ -148,7 +142,17 @@ dial (CallsOrigin *origin, const gchar *number) self->calls = g_list_append (self->calls, dummy_call); - g_signal_emit_by_name (origin, "call-added", call); + g_signal_emit_by_name (CALLS_ORIGIN (self), "call-added", call); +} + + +static void +dial (CallsOrigin *origin, const gchar *number) +{ + g_return_if_fail (number != NULL); + g_return_if_fail (CALLS_IS_DUMMY_ORIGIN (origin)); + + add_call (CALLS_DUMMY_ORIGIN (origin), number, FALSE); } @@ -245,3 +249,14 @@ calls_dummy_origin_init (CallsDummyOrigin *self) { self->name = g_string_new (NULL); } + + +void +calls_dummy_origin_create_inbound (CallsDummyOrigin *self, + const gchar *number) +{ + g_return_if_fail (number != NULL); + g_return_if_fail (CALLS_IS_DUMMY_ORIGIN (self)); + + add_call (self, number, TRUE); +} diff --git a/plugins/dummy/calls-dummy-origin.h b/plugins/dummy/calls-dummy-origin.h index eb91618..e99ba2f 100644 --- a/plugins/dummy/calls-dummy-origin.h +++ b/plugins/dummy/calls-dummy-origin.h @@ -33,7 +33,9 @@ G_BEGIN_DECLS G_DECLARE_FINAL_TYPE (CallsDummyOrigin, calls_dummy_origin, CALLS, DUMMY_ORIGIN, GObject); -CallsDummyOrigin *calls_dummy_origin_new (const gchar *name); +CallsDummyOrigin *calls_dummy_origin_new (const gchar *name); +void calls_dummy_origin_create_inbound (CallsDummyOrigin *self, + const gchar *number); G_END_DECLS diff --git a/plugins/dummy/calls-dummy-provider.c b/plugins/dummy/calls-dummy-provider.c index cce29ef..d5427af 100644 --- a/plugins/dummy/calls-dummy-provider.c +++ b/plugins/dummy/calls-dummy-provider.c @@ -28,6 +28,7 @@ #include "calls-dummy-origin.h" #include +#include struct _CallsDummyProvider @@ -82,6 +83,22 @@ get_origins (CallsProvider *iface) } +static gboolean +usr1_handler (CallsDummyProvider *self) +{ + CallsDummyOrigin *origin; + + g_return_val_if_fail (self->origins != NULL, FALSE); + + g_debug ("Received SIGUSR1, adding new incoming call"); + + origin = CALLS_DUMMY_ORIGIN (self->origins->data); + calls_dummy_origin_create_inbound (origin, "0987654321"); + + return TRUE; +} + + static void constructed (GObject *object) { @@ -90,6 +107,10 @@ constructed (GObject *object) calls_dummy_provider_add_origin (self, "Dummy origin"); + g_unix_signal_add (SIGUSR1, + (GSourceFunc)usr1_handler, + self); + parent_class->constructed (object); } diff --git a/plugins/mm/calls-mm-call.c b/plugins/mm/calls-mm-call.c index 467147e..a7c304b 100644 --- a/plugins/mm/calls-mm-call.c +++ b/plugins/mm/calls-mm-call.c @@ -52,6 +52,7 @@ G_DEFINE_TYPE_WITH_CODE (CallsMMCall, calls_mm_call, G_TYPE_OBJECT, enum { PROP_0, PROP_MM_CALL, + PROP_INBOUND, PROP_LAST_PROP, }; static GParamSpec *props[PROP_LAST_PROP]; @@ -334,6 +335,28 @@ constructed (GObject *object) } +static void +get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + CallsMMCall *self = CALLS_MM_CALL (object); + + switch (property_id) { + case PROP_INBOUND: + g_value_set_boolean (value, + mm_call_get_direction (self->mm_call) + == MM_CALL_DIRECTION_INCOMING); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + + static void dispose (GObject *object) { @@ -364,6 +387,7 @@ calls_mm_call_class_init (CallsMMCallClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); + object_class->get_property = get_property; object_class->set_property = set_property; object_class->constructed = constructed; object_class->dispose = dispose; @@ -375,8 +399,17 @@ calls_mm_call_class_init (CallsMMCallClass *klass) _("A libmm-glib proxy object for the underlying call object"), MM_TYPE_CALL, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY); + g_object_class_install_property (object_class, PROP_MM_CALL, + props[PROP_MM_CALL]); - g_object_class_install_properties (object_class, PROP_LAST_PROP, props); + + props[PROP_INBOUND] = + g_param_spec_boolean ("inbound", + _("Inbound"), + _("Whether the call is inbound"), + FALSE, + G_PARAM_READABLE | G_PARAM_CONSTRUCT); + g_object_class_override_property (object_class, PROP_INBOUND, "inbound"); } diff --git a/src/calls-call-display.c b/src/calls-call-display.c index a8c3431..4fee4fa 100644 --- a/src/calls-call-display.c +++ b/src/calls-call-display.c @@ -41,16 +41,17 @@ struct _CallsCallDisplay GTimer *timer; guint timeout; + GtkLabel *incoming_phone_call; GtkBox *party_box; GtkLabel *primary_contact_info; GtkLabel *secondary_contact_info; GtkLabel *status; - GtkLabel *time; - GtkButton *answer; - GtkToggleButton *mute; + GtkBox *controls; + GtkBox *gsm_controls; + GtkBox *general_controls; GtkButton *hang_up; - GtkToggleButton *speaker; + GtkButton *answer; GtkRevealer *dial_pad_revealer; }; @@ -88,6 +89,12 @@ hang_up_clicked_cb (GtkButton *button, } } +static void +hold_toggled_cb (GtkToggleButton *togglebutton, + CallsCallDisplay *self) +{ +} + static void mute_toggled_cb (GtkToggleButton *togglebutton, CallsCallDisplay *self) @@ -101,6 +108,13 @@ speaker_toggled_cb (GtkToggleButton *togglebutton, } +static void +add_call_clicked_cb (GtkButton *button, + CallsCallDisplay *self) +{ +} + + static void dial_pad_symbol_clicked_cb (CallsCallDisplay *self, gchar symbol, @@ -157,7 +171,7 @@ timeout_cb (CallsCallDisplay *self) g_string_append_printf (str, "%02u", (guint)elapsed); - gtk_label_set_text (self->time, str->str); + gtk_label_set_text (self->status, str->str); g_string_free (str, TRUE); return TRUE; @@ -167,38 +181,91 @@ timeout_cb (CallsCallDisplay *self) #undef MINUTE } + +static void +stop_timeout (CallsCallDisplay *self) +{ + if (self->timeout == 0) + { + return; + } + + g_source_remove (self->timeout); + self->timeout = 0; +} + + static void call_state_changed_cb (CallsCallDisplay *self, CallsCallState state) { - GString *state_str = g_string_new(""); + GtkStyleContext *hang_up_style; g_return_if_fail (CALLS_IS_CALL_DISPLAY (self)); - calls_call_state_to_string (state_str, state); - gtk_label_set_text (self->status, state_str->str); - g_debug ("Call state changed to `%s'", state_str->str); - g_string_free (state_str, TRUE); + hang_up_style = gtk_widget_get_style_context + (GTK_WIDGET (self->hang_up)); + /* Widgets */ switch (state) { case CALLS_CALL_STATE_INCOMING: + gtk_widget_hide (GTK_WIDGET (self->status)); + gtk_widget_hide (GTK_WIDGET (self->controls)); + gtk_widget_show (GTK_WIDGET (self->incoming_phone_call)); gtk_widget_show (GTK_WIDGET (self->answer)); - gtk_widget_hide (GTK_WIDGET (self->mute)); - gtk_widget_hide (GTK_WIDGET (self->speaker)); + gtk_style_context_remove_class + (hang_up_style, GTK_STYLE_CLASS_DESTRUCTIVE_ACTION); break; - case CALLS_CALL_STATE_ACTIVE: - case CALLS_CALL_STATE_HELD: + case CALLS_CALL_STATE_DIALING: case CALLS_CALL_STATE_ALERTING: + case CALLS_CALL_STATE_ACTIVE: + case CALLS_CALL_STATE_HELD: case CALLS_CALL_STATE_WAITING: + gtk_style_context_add_class + (hang_up_style, GTK_STYLE_CLASS_DESTRUCTIVE_ACTION); gtk_widget_hide (GTK_WIDGET (self->answer)); - gtk_widget_show (GTK_WIDGET (self->mute)); - gtk_widget_show (GTK_WIDGET (self->speaker)); + gtk_widget_hide (GTK_WIDGET (self->incoming_phone_call)); + gtk_widget_show (GTK_WIDGET (self->controls)); + gtk_widget_show (GTK_WIDGET (self->status)); + + gtk_widget_set_visible + (GTK_WIDGET (self->gsm_controls), + state != CALLS_CALL_STATE_DIALING + && state != CALLS_CALL_STATE_ALERTING); break; + case CALLS_CALL_STATE_DISCONNECTED: break; } + + /* Status text */ + switch (state) + { + case CALLS_CALL_STATE_INCOMING: + break; + + case CALLS_CALL_STATE_DIALING: + case CALLS_CALL_STATE_ALERTING: + gtk_label_set_text (self->status, _("Calling...")); + break; + + case CALLS_CALL_STATE_ACTIVE: + case CALLS_CALL_STATE_HELD: + case CALLS_CALL_STATE_WAITING: + if (self->timeout == 0) + { + self->timeout = g_timeout_add + (500, (GSourceFunc)timeout_cb, self); + timeout_cb (self); + } + break; + + case CALLS_CALL_STATE_DISCONNECTED: + stop_timeout (self); + break; + } } @@ -230,7 +297,7 @@ set_party (CallsCallDisplay *self, CallsParty *party) const gchar *name, *number; image = calls_party_create_image (party); - gtk_box_pack_end (self->party_box, image, TRUE, FALSE, 0); + gtk_box_pack_end (self->party_box, image, TRUE, TRUE, 0); gtk_image_set_pixel_size (GTK_IMAGE (image), 100); gtk_widget_show (image); @@ -276,8 +343,6 @@ constructed (GObject *object) CallsCallDisplay *self = CALLS_CALL_DISPLAY (object); self->timer = g_timer_new (); - self->timeout = g_timeout_add (500, (GSourceFunc)timeout_cb, self); - timeout_cb (self); call_state_changed_cb (self, calls_call_get_state (self->call)); @@ -296,6 +361,7 @@ dispose (GObject *object) GObjectClass *parent_class = g_type_class_peek (GTK_TYPE_OVERLAY); CallsCallDisplay *self = CALLS_CALL_DISPLAY (object); + stop_timeout (self); g_clear_object (&self->call); parent_class->dispose (object); @@ -307,7 +373,6 @@ finalize (GObject *object) GObjectClass *parent_class = g_type_class_peek (GTK_TYPE_OVERLAY); CallsCallDisplay *self = CALLS_CALL_DISPLAY (object); - g_source_remove (self->timeout); g_timer_destroy (self->timer); parent_class->finalize (object); @@ -335,20 +400,23 @@ calls_call_display_class_init (CallsCallDisplayClass *klass) gtk_widget_class_set_template_from_resource (widget_class, "/sm/puri/calls/ui/call-display.ui"); + gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, incoming_phone_call); gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, party_box); gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, primary_contact_info); gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, secondary_contact_info); gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, status); - gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, time); - gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, answer); - gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, mute); + gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, controls); + gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, gsm_controls); + gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, general_controls); gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, hang_up); - gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, speaker); + gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, answer); gtk_widget_class_bind_template_child (widget_class, CallsCallDisplay, dial_pad_revealer); gtk_widget_class_bind_template_callback (widget_class, answer_clicked_cb); gtk_widget_class_bind_template_callback (widget_class, hang_up_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, hold_toggled_cb); gtk_widget_class_bind_template_callback (widget_class, mute_toggled_cb); gtk_widget_class_bind_template_callback (widget_class, speaker_toggled_cb); + gtk_widget_class_bind_template_callback (widget_class, add_call_clicked_cb); gtk_widget_class_bind_template_callback (widget_class, dial_pad_symbol_clicked_cb); gtk_widget_class_bind_template_callback (widget_class, hide_dial_pad_clicked_cb); } diff --git a/src/calls-call-window.c b/src/calls-call-window.c index ee82382..2c57a10 100644 --- a/src/calls-call-window.c +++ b/src/calls-call-window.c @@ -45,6 +45,8 @@ struct _CallsCallWindow GListStore *call_holders; + GtkRevealer *info_revealer; + guint info_timeout; GtkInfoBar *info; GtkLabel *info_label; @@ -85,6 +87,15 @@ update_visibility (CallsCallWindow *self) } +static gboolean +show_message_timeout_cb (CallsCallWindow *self) +{ + gtk_revealer_set_reveal_child (self->info_revealer, FALSE); + self->info_timeout = 0; + return FALSE; +} + + static void show_message (CallsCallWindow *self, const gchar *text, @@ -92,8 +103,27 @@ show_message (CallsCallWindow *self, { gtk_info_bar_set_message_type (self->info, type); gtk_label_set_text (self->info_label, text); - gtk_widget_show (GTK_WIDGET (self->info)); - gtk_widget_queue_allocate (GTK_WIDGET (self)); + gtk_revealer_set_reveal_child (self->info_revealer, TRUE); + + if (self->info_timeout) + { + g_source_remove (self->info_timeout); + } + self->info_timeout = g_timeout_add_seconds + (3, + (GSourceFunc)show_message_timeout_cb, + self); +} + + +static inline void +stop_info_timeout (CallsCallWindow *self) +{ + if (self->info_timeout) + { + g_source_remove (self->info_timeout); + self->info_timeout = 0; + } } @@ -102,8 +132,8 @@ info_response_cb (GtkInfoBar *infobar, gint response_id, CallsCallWindow *self) { - gtk_widget_hide (GTK_WIDGET (self->info)); - gtk_widget_queue_allocate (GTK_WIDGET (self)); + stop_info_timeout (self); + gtk_revealer_set_reveal_child (self->info_revealer, FALSE); } @@ -376,6 +406,7 @@ dispose (GObject *object) } g_clear_object (&self->call_holders); + stop_info_timeout (self); parent_class->dispose (object); } @@ -401,6 +432,7 @@ calls_call_window_class_init (CallsCallWindowClass *klass) g_object_class_install_properties (object_class, PROP_LAST_PROP, props); gtk_widget_class_set_template_from_resource (widget_class, "/sm/puri/calls/ui/call-window.ui"); + gtk_widget_class_bind_template_child (widget_class, CallsCallWindow, info_revealer); gtk_widget_class_bind_template_child (widget_class, CallsCallWindow, info); gtk_widget_class_bind_template_child (widget_class, CallsCallWindow, info_label); gtk_widget_class_bind_template_child (widget_class, CallsCallWindow, main_stack); diff --git a/src/calls-call.c b/src/calls-call.c index 134e919..e1d3d6e 100644 --- a/src/calls-call.c +++ b/src/calls-call.c @@ -27,6 +27,8 @@ #include "enum-types.h" #include "util.h" +#include + void calls_call_state_to_string (GString *string, @@ -92,6 +94,13 @@ calls_call_state_parse_nick (CallsCallState *state, G_DEFINE_INTERFACE (CallsCall, calls_call, CALLS_TYPE_MESSAGE_SOURCE); +enum { + PROP_0, + PROP_INBOUND, + PROP_LAST_PROP, +}; +static GParamSpec *props[PROP_LAST_PROP]; + enum { SIGNAL_STATE_CHANGED, SIGNAL_LAST_SIGNAL, @@ -108,6 +117,15 @@ calls_call_default_init (CallsCallInterface *iface) CALLS_TYPE_CALL_STATE }; + props[PROP_INBOUND] = + g_param_spec_boolean ("inbound", + _("Inbound"), + _("Whether the call is inbound"), + FALSE, + G_PARAM_READABLE); + + g_object_interface_install_property (iface, props[PROP_INBOUND]); + /** * CallsCall::state-changed: * @self: The #CallsCall instance. diff --git a/src/calls-call.h b/src/calls-call.h index 23dd148..9e51913 100644 --- a/src/calls-call.h +++ b/src/calls-call.h @@ -35,7 +35,7 @@ G_DECLARE_INTERFACE (CallsCall, calls_call, CALLS, CALL, GObject); typedef enum { - CALLS_CALL_STATE_ACTIVE, + CALLS_CALL_STATE_ACTIVE = 1, CALLS_CALL_STATE_HELD, CALLS_CALL_STATE_DIALING, CALLS_CALL_STATE_ALERTING, diff --git a/src/calls-main-window.c b/src/calls-main-window.c index 7336eca..b981053 100644 --- a/src/calls-main-window.c +++ b/src/calls-main-window.c @@ -44,6 +44,8 @@ struct _CallsMainWindow CallsProvider *provider; + GtkRevealer *info_revealer; + guint info_timeout; GtkInfoBar *info; GtkLabel *info_label; @@ -145,13 +147,41 @@ calls_main_window_new (GtkApplication *application, CallsProvider *provider) } +static gboolean +show_message_timeout_cb (CallsMainWindow *self) +{ + gtk_revealer_set_reveal_child (self->info_revealer, FALSE); + self->info_timeout = 0; + return FALSE; +} + + static void show_message (CallsMainWindow *self, const gchar *text, GtkMessageType type) { gtk_info_bar_set_message_type (self->info, type); gtk_label_set_text (self->info_label, text); - gtk_widget_show (GTK_WIDGET (self->info)); - gtk_widget_queue_allocate (GTK_WIDGET (self)); + gtk_revealer_set_reveal_child (self->info_revealer, TRUE); + + if (self->info_timeout) + { + g_source_remove (self->info_timeout); + } + self->info_timeout = g_timeout_add_seconds + (3, + (GSourceFunc)show_message_timeout_cb, + self); +} + + +static inline void +stop_info_timeout (CallsMainWindow *self) +{ + if (self->info_timeout) + { + g_source_remove (self->info_timeout); + self->info_timeout = 0; + } } @@ -160,8 +190,8 @@ info_response_cb (GtkInfoBar *infobar, gint response_id, CallsMainWindow *self) { - gtk_widget_hide (GTK_WIDGET (self->info)); - gtk_widget_queue_allocate (GTK_WIDGET (self)); + stop_info_timeout (self); + gtk_revealer_set_reveal_child (self->info_revealer, FALSE); } @@ -269,6 +299,7 @@ dispose (GObject *object) GObjectClass *parent_class = g_type_class_peek (GTK_TYPE_APPLICATION_WINDOW); CallsMainWindow *self = CALLS_MAIN_WINDOW (object); + stop_info_timeout (self); g_clear_object (&self->provider); parent_class->dispose (object); @@ -296,6 +327,7 @@ calls_main_window_class_init (CallsMainWindowClass *klass) gtk_widget_class_set_template_from_resource (widget_class, "/sm/puri/calls/ui/main-window.ui"); + gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, info_revealer); gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, info); gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, info_label); gtk_widget_class_bind_template_child (widget_class, CallsMainWindow, main_stack); diff --git a/src/calls.gresources.xml b/src/calls.gresources.xml index 73577f7..34bc78e 100644 --- a/src/calls.gresources.xml +++ b/src/calls.gresources.xml @@ -11,4 +11,7 @@ new-call-box.ui new-call-header-bar.ui + + new-call-symbolic.svg + diff --git a/src/meson.build b/src/meson.build index 1e109a2..86880ce 100644 --- a/src/meson.build +++ b/src/meson.build @@ -76,7 +76,7 @@ calls_enum_sources = gnome.mkenums_simple('enum-types', calls_resources = gnome.compile_resources( 'calls-resources', 'calls.gresources.xml', - source_dir: 'ui', + source_dir: ['ui', '../data'], c_name: 'call', ) diff --git a/src/ui/call-display.ui b/src/ui/call-display.ui index dd46ccd..597d274 100644 --- a/src/ui/call-display.ui +++ b/src/ui/call-display.ui @@ -9,144 +9,302 @@ False center - 8 + 12 12 12 - 8 + 12 vertical - center + True True 300 - - - True - False - vertical - - - True - False - 6 - 6 - - - - - - - - - True - False - 4 - 4 - - - - True False vertical + True - - True + + False False - Active + 40 + 12 + Incoming phone call - + True False - 00:00 - 30 - 40 - - - - - - - - Answer - True - True - True - True - + vertical + True + + + True + False + 6 + 6 + + + + + + + + + True + False + 4 + 4 + + True False - 12 - True - 65 - 65 + vertical - + True - True - True - True - - - - True - False - microphone-sensitivity-muted-symbolic - 3 - - + False + 30 + 40 + + + - + True - True - True - True - + False + 12 + True + vertical + False - + True False - input-dialpad-symbolic - 3 + 12 + 65 + True + True + + + True + True + True + True + True + False + + + + True + False + vertical + + + True + False + microphone-sensitivity-muted-symbolic + 3 + True + + + + + True + False + 4 + Mute + + + + + + + + + True + True + True + True + True + False + + + + True + False + vertical + + + True + False + audio-volume-high-symbolic + 3 + True + + + + + True + False + 4 + Speaker + + + + + + + + + True + True + True + True + False + + + + True + False + vertical + + + True + False + /sm/puri/calls/new-call-symbolic.svg + 3 + True + + + + + True + False + 4 + Add call + + + + + + - - - - - True - True - True - True - - + True False - audio-volume-high-symbolic - 3 + 12 + 65 + + + True + True + True + True + True + False + + + + True + False + vertical + + + True + False + media-playback-pause-symbolic + 3 + True + + + + + True + False + 4 + Hold + + + + + + + + + True + True + True + True + + True + + + True + False + vertical + + + True + False + input-dialpad-symbolic + 3 + True + + + + + True + False + 4 + Dial pad + + + + + + + + + True + True + True + True + True + + - - - False - 30 - True - - + + + + + False + 50 + 30 + True + + + + + True + False + horizontal + True True @@ -157,6 +315,7 @@ start True 150 + True + + + Answer + + + + + True + call-start-symbolic + 5 + + + + @@ -254,4 +444,14 @@ + + + + + + + + + + diff --git a/src/ui/call-window.ui b/src/ui/call-window.ui index a46ac24..d0ba139 100644 --- a/src/ui/call-window.ui +++ b/src/ui/call-window.ui @@ -11,40 +11,52 @@ Calls - + True False - vertical - - + + + True False - True - True - - - + start + False + slide-down + + + True False - 6 - end - - - - - - False - False - - - - - False - 16 - - - True + True + + + False - label - True + 6 + end + + + + + + False + False + + + + + False + 16 + + + True + False + label + True + + + True + True + + True @@ -52,10 +64,6 @@ - - True - True - @@ -102,10 +110,6 @@ - - True - True - diff --git a/src/ui/main-window.ui b/src/ui/main-window.ui index 1967f91..7395b79 100644 --- a/src/ui/main-window.ui +++ b/src/ui/main-window.ui @@ -10,61 +10,61 @@ False - + True False - vertical - - + + + True False - True - True - - - + start + False + slide-down + + + True False - 6 - end - - - - - - False - False - 0 - - - - - False - 16 - - - True + True + + + False - label - True + 6 + end + + + + + + False + False + + + + + False + 16 + + + True + False + label + True + + + True + True + + True True - 0 - - True - True - 0 - - - True - True - 1 - @@ -81,11 +81,6 @@ - - True - True - 2 - diff --git a/tests/test-call.c b/tests/test-call.c index 6e0511a..3eec526 100644 --- a/tests/test-call.c +++ b/tests/test-call.c @@ -39,7 +39,7 @@ test_dummy_call_get_state (CallFixture *fixture, { CallsCallState state; state = calls_call_get_state (CALLS_CALL (fixture->dummy_call)); - g_assert_true (state == CALLS_CALL_STATE_ACTIVE); + g_assert_true (state == CALLS_CALL_STATE_DIALING); }