static void
show_view_default_cb(GSimpleAction* action,
GVariant* arg,
gpointer udata)
{
GtWin* self = GT_WIN(udata);
GtWinPrivate* priv = gt_win_get_instance_private(self);
if (gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack)) == priv->channels_view)
gt_channels_view_show_type(GT_CHANNELS_VIEW(priv->channels_view), GT_CHANNELS_CONTAINER_TYPE_TOP);
else if (gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack)) == priv->games_view)
gt_games_view_show_type(GT_GAMES_VIEW(priv->games_view), GT_GAMES_CONTAINER_TYPE_TOP);
}
/**
* ide_workbench_get_visible_perspective:
* @self: An #IdeWorkbench.
*
* Gets the current perspective.
*
* Returns: (transfer none): An #IdePerspective.
*/
IdePerspective *
ide_workbench_get_visible_perspective (IdeWorkbench *self)
{
GtkWidget *visible_child;
g_return_val_if_fail (IDE_IS_WORKBENCH (self), NULL);
visible_child = gtk_stack_get_visible_child (self->top_stack);
if (IDE_IS_PERSPECTIVE (visible_child))
return IDE_PERSPECTIVE (visible_child);
return IDE_PERSPECTIVE (gtk_stack_get_visible_child (self->perspectives_stack));
}
static void
search_text_changed (GtkEntry *entry)
{
ExampleAppWindow *win;
ExampleAppWindowPrivate *priv;
const gchar *text;
GtkWidget *tab;
GtkWidget *view;
GtkTextBuffer *buffer;
GtkTextIter start, match_start, match_end;
text = gtk_entry_get_text (entry);
if (text[0] == '\0')
return;
win = EXAMPLE_APP_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (entry)));
priv = example_app_window_get_instance_private (win);
tab = gtk_stack_get_visible_child (GTK_STACK (priv->stack));
view = gtk_bin_get_child (GTK_BIN (tab));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
/* Very simple-minded search implementation */
gtk_text_buffer_get_start_iter (buffer, &start);
if (gtk_text_iter_forward_search (&start, text, GTK_TEXT_SEARCH_CASE_INSENSITIVE,
&match_start, &match_end, NULL))
{
gtk_text_buffer_select_range (buffer, &match_start, &match_end);
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (view), &match_start,
0.0, FALSE, 0.0, 0.0);
}
}
static void
update_lines (ExampleAppWindow *win)
{
ExampleAppWindowPrivate *priv;
GtkWidget *tab, *view;
GtkTextBuffer *buffer;
GtkTextIter iter;
int count;
gchar *lines;
priv = example_app_window_get_instance_private (win);
tab = gtk_stack_get_visible_child (GTK_STACK (priv->stack));
if (tab == NULL)
return;
view = gtk_bin_get_child (GTK_BIN (tab));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
count = 0;
gtk_text_buffer_get_start_iter (buffer, &iter);
while (!gtk_text_iter_is_end (&iter))
{
count++;
if (!gtk_text_iter_forward_line (&iter))
break;
}
lines = g_strdup_printf ("%d", count);
gtk_label_set_text (GTK_LABEL (priv->lines), lines);
g_free (lines);
}
static GtkWidget *
ev_sidebar_get_current_page (EvSidebar *ev_sidebar)
{
EvSidebarPrivate *priv = GET_PRIVATE (ev_sidebar);
return gtk_stack_get_visible_child (GTK_STACK (priv->stack));
}
static void
ide_frame_change_current_page (IdeFrame *self,
gint direction)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
g_autoptr(GPtrArray) ar = NULL;
GtkWidget *visible_child;
gint position = 0;
g_assert (IDE_IS_FRAME (self));
visible_child = gtk_stack_get_visible_child (priv->stack);
if (visible_child == NULL)
return;
gtk_container_child_get (GTK_CONTAINER (priv->stack), visible_child,
"position", &position,
NULL);
ar = g_ptr_array_new ();
gtk_container_foreach (GTK_CONTAINER (priv->stack), collect_widgets, ar);
if (ar->len == 0)
g_return_if_reached ();
visible_child = g_ptr_array_index (ar, (position + direction) % ar->len);
gtk_stack_set_visible_child (priv->stack, visible_child);
}
static void
update_title_stack (GtkShortcutsWindow *self)
{
GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
GtkWidget *visible_child;
visible_child = gtk_stack_get_visible_child (priv->stack);
if (GTK_IS_SHORTCUTS_SECTION (visible_child))
{
if (number_of_children (GTK_CONTAINER (priv->stack)) > 3)
{
gchar *title;
gtk_stack_set_visible_child_name (priv->title_stack, "sections");
g_object_get (visible_child, "title", &title, NULL);
gtk_label_set_label (priv->menu_label, title);
g_free (title);
}
else
{
gtk_stack_set_visible_child_name (priv->title_stack, "title");
}
}
else if (visible_child != NULL)
{
gtk_stack_set_visible_child_name (priv->title_stack, "search");
}
}
static void
gb_shortcuts_dialog__stack__notify_visible_child (GbShortcutsDialog *self,
GParamSpec *pspec,
GtkStack *stack)
{
GbShortcutsDialogPrivate *priv = gb_shortcuts_dialog_get_instance_private (self);
GtkWidget *visible_child;
visible_child = gtk_stack_get_visible_child (stack);
if (GB_IS_SHORTCUTS_VIEW (visible_child))
{
const gchar *title;
title = gb_shortcuts_view_get_title (GB_SHORTCUTS_VIEW (visible_child));
gtk_label_set_label (priv->menu_label, title);
}
else if (visible_child != NULL)
{
g_autofree gchar *title = NULL;
gtk_container_child_get (GTK_CONTAINER (stack), visible_child,
"title", &title,
NULL);
gtk_label_set_label (priv->menu_label, title);
}
}
static void
get_property (GObject* obj,
guint prop,
GValue* val,
GParamSpec* pspec)
{
GtWin* self = GT_WIN(obj);
GtWinPrivate* priv = gt_win_get_instance_private(self);
switch (prop)
{
case PROP_CHANNELS_VIEW:
g_value_set_object(val, priv->channels_view);
break;
case PROP_GAMES_VIEW:
g_value_set_object(val, priv->games_view);
break;
case PROP_FULLSCREEN:
g_value_set_boolean(val, priv->fullscreen);
break;
case PROP_VISIBLE_VIEW:
g_value_set_object(val, gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop, pspec);
}
}
static void
ide_workbench_notify_visible_child (IdeWorkbench *self,
GParamSpec *pspec,
GtkStack *stack)
{
IdePerspective *perspective;
g_assert (IDE_IS_WORKBENCH (self));
g_assert (GTK_IS_STACK (stack));
perspective = IDE_PERSPECTIVE (gtk_stack_get_visible_child (stack));
if (perspective != NULL)
{
GActionGroup *actions;
gchar *id;
id = ide_perspective_get_id (perspective);
gtk_stack_set_visible_child_name (self->titlebar_stack, id);
actions = ide_perspective_get_actions (perspective);
gtk_widget_insert_action_group (GTK_WIDGET (self), "perspective", actions);
g_clear_object (&actions);
g_free (id);
}
}
static void
gb_shortcuts_dialog_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GbShortcutsDialog *self = (GbShortcutsDialog *)object;
GbShortcutsDialogPrivate *priv = gb_shortcuts_dialog_get_instance_private (self);
switch (prop_id)
{
case PROP_VIEW_NAME:
{
GtkWidget *child = gtk_stack_get_visible_child (priv->stack);
if (child != NULL)
{
gchar *name = NULL;
gtk_container_child_get (GTK_CONTAINER (priv->stack), child,
"name", &name,
NULL);
g_value_take_string (value, name);
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
update_words (ExampleAppWindow *win)
{
ExampleAppWindowPrivate *priv;
GHashTable *strings;
GHashTableIter iter;
GtkWidget *tab, *view, *row;
GtkTextBuffer *buffer;
GtkTextIter start, end;
GList *children, *l;
gchar *word, *key;
priv = example_app_window_get_instance_private (win);
tab = gtk_stack_get_visible_child (GTK_STACK (priv->stack));
if (tab == NULL)
return;
view = gtk_bin_get_child (GTK_BIN (tab));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
strings = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
gtk_text_buffer_get_start_iter (buffer, &start);
while (!gtk_text_iter_is_end (&start))
{
while (!gtk_text_iter_starts_word (&start))
{
if (!gtk_text_iter_forward_char (&start))
goto done;
}
end = start;
if (!gtk_text_iter_forward_word_end (&end))
goto done;
word = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
g_hash_table_add (strings, g_utf8_strdown (word, -1));
g_free (word);
start = end;
}
done:
children = gtk_container_get_children (GTK_CONTAINER (priv->words));
for (l = children; l; l = l->next)
gtk_container_remove (GTK_CONTAINER (priv->words), GTK_WIDGET (l->data));
g_list_free (children);
g_hash_table_iter_init (&iter, strings);
while (g_hash_table_iter_next (&iter, (gpointer *)&key, NULL))
{
row = gtk_button_new_with_label (key);
g_signal_connect (row, "clicked",
G_CALLBACK (find_word), win);
gtk_widget_show (row);
gtk_container_add (GTK_CONTAINER (priv->words), row);
}
g_hash_table_unref (strings);
}
static void
libre_impuesto_open_form(LibreImpuesto * impuesto, const gchar * args)
{
GtkNotebook * notebook;
GtkWindow * impuesto_window = libre_impuesto_get_active_window(impuesto);
GtkWidget * widget, * switcher, * tree_view;
LibreImpuestoEmbed * embed;
WebKitWebView *webview;
GtkTreeSelection * selection;
GtkTreeIter selected;
GtkTreePath * path;
gchar *fileURL;
gint current;
if (args == NULL) {
action_message_cb (NULL, impuesto_window);
return;
}
notebook = libre_impuesto_window_get_notebook(LIBRE_IMPUESTO_WINDOW(impuesto_window));
current = libre_impuesto_find_page_data(notebook, args);
if (current == -1) {
embed = LIBRE_IMPUESTO_EMBED (g_object_new (LIBRE_IMPUESTO_TYPE_EMBED, NULL));
g_assert (embed != NULL);
switcher = g_object_get_data ( G_OBJECT(impuesto_window), "switcher");
tree_view = gtk_stack_get_visible_child(gtk_stack_switcher_get_stack (GTK_STACK_SWITCHER(switcher)));
tree_view = gtk_bin_get_child(GTK_BIN(tree_view));
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
gtk_tree_selection_get_selected (selection, NULL, &selected);
path = gtk_tree_model_get_path (gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)), &selected);
g_object_set_data(G_OBJECT(embed), "impuesto-window", impuesto_window);
g_object_set_data(G_OBJECT(embed), "tree-view", tree_view);
g_object_set_data(G_OBJECT(embed), "path", path);
g_object_set_data(G_OBJECT(embed), "form", g_strdup(args));
webview = libre_impuesto_embed_get_web_view (LIBRE_IMPUESTO_EMBED(embed));
widget = gtk_label_new(NULL);
current = gtk_notebook_append_page (notebook, GTK_WIDGET(embed), widget );
gtk_widget_show (GTK_WIDGET (embed));
fileURL = filenameToURL(args);
webkit_web_view_load_uri(WEBKIT_WEB_VIEW(webview), fileURL ? fileURL : args);
g_free(fileURL);
gtk_notebook_set_current_page(notebook, current);
}
else
gtk_notebook_set_current_page(notebook, current);
if ( gtk_notebook_get_n_pages (libre_impuesto_window_get_notebook(LIBRE_IMPUESTO_WINDOW(impuesto_window))) > 0 )
gtk_stack_set_visible_child_name(libre_impuesto_window_get_stack(LIBRE_IMPUESTO_WINDOW(impuesto_window)), "notebook");
else
gtk_stack_set_visible_child_name(libre_impuesto_window_get_stack(LIBRE_IMPUESTO_WINDOW(impuesto_window)), "background");
}
/**
* ide_frame_get_visible_child:
* @self: a #IdeFrame
*
* Gets the visible #IdePage if there is one; otherwise %NULL.
*
* Returns: (nullable) (transfer none): An #IdePage or %NULL
*
* Since: 3.32
*/
IdePage *
ide_frame_get_visible_child (IdeFrame *self)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
g_return_val_if_fail (IDE_IS_FRAME (self), NULL);
return IDE_PAGE (gtk_stack_get_visible_child (priv->stack));
}
/**
* ide_workbench_get_visible_perspective:
* @self: An #IdeWorkbench.
*
* Gets the current perspective.
*
* Returns: (transfer none): An #IdePerspective.
*/
IdePerspective *
ide_workbench_get_visible_perspective (IdeWorkbench *self)
{
GtkWidget *ret;
g_return_val_if_fail (IDE_IS_WORKBENCH (self), NULL);
ret = gtk_stack_get_visible_child (self->perspectives_stack);
return IDE_PERSPECTIVE (ret);
}
static void
ide_frame_notify_visible_child (IdeFrame *self,
GParamSpec *pspec,
GtkStack *stack)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
GtkWidget *visible_child;
g_assert (IDE_IS_FRAME (self));
g_assert (GTK_IS_STACK (stack));
if (gtk_widget_in_destruction (GTK_WIDGET (self)))
return;
if ((visible_child = gtk_stack_get_visible_child (priv->stack)))
{
if (gtk_widget_in_destruction (visible_child))
visible_child = NULL;
}
/*
* Mux/Proxy actions to our level so that they also be activated
* from the header bar without any weirdness by the View.
*/
dzl_gtk_widget_mux_action_groups (GTK_WIDGET (self), visible_child,
"IDE_FRAME_MUXED_ACTION");
/* Update our bindings targets */
dzl_binding_group_set_source (priv->bindings, visible_child);
dzl_signal_group_set_target (priv->signals, visible_child);
/* Show either the empty state, failed state, or actual page */
if (visible_child != NULL &&
ide_page_get_failed (IDE_PAGE (visible_child)))
gtk_stack_set_visible_child (priv->top_stack, GTK_WIDGET (priv->failed_state));
else if (visible_child != NULL)
gtk_stack_set_visible_child (priv->top_stack, GTK_WIDGET (priv->stack));
else
gtk_stack_set_visible_child (priv->top_stack, GTK_WIDGET (priv->empty_placeholder));
/* Allow the header to update settings */
_ide_frame_header_update (priv->header, IDE_PAGE (visible_child));
/* Ensure action state is up to date */
_ide_frame_update_actions (self);
if (priv->addins != NULL)
peas_extension_set_foreach (priv->addins,
ide_frame_notify_addin_of_page,
visible_child);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_VISIBLE_CHILD]);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_HAS_VIEW]);
}
static void
gb_view_stack_grab_focus (GtkWidget *widget)
{
GbViewStack *self = (GbViewStack *)widget;
GtkWidget *visible_child;
g_assert (GB_IS_VIEW_STACK (self));
visible_child = gtk_stack_get_visible_child (self->stack);
if (visible_child)
gtk_widget_grab_focus (visible_child);
}
static gboolean
key_press_cb(GtkWidget* widget,
GdkEventKey* evt,
gpointer udata)
{
GtWin* self = GT_WIN(udata);
GtWinPrivate* priv = gt_win_get_instance_private(self);
GdkModifierType modifiers = gtk_accelerator_get_default_mod_mask();
gboolean playing;
GAction *action;
g_object_get(self->player, "playing", &playing, NULL);
if (MAIN_VISIBLE_CHILD == GTK_WIDGET(self->player))
{
if (evt->keyval == GDK_KEY_Escape)
{
if (priv->fullscreen)
g_object_set(self, "fullscreen", FALSE, NULL);
else
{
action = g_action_map_lookup_action(G_ACTION_MAP(self), "close_player");
g_action_activate(action, NULL);
}
}
else if (evt->keyval == GDK_KEY_f)
{
g_object_set(self, "fullscreen", !priv->fullscreen, NULL);
}
}
else
{
if (evt->keyval == GDK_KEY_Escape)
gt_browse_header_bar_stop_search(GT_BROWSE_HEADER_BAR(priv->browse_header_bar));
else if (evt->keyval == GDK_KEY_f && (evt->state & modifiers) == GDK_CONTROL_MASK)
gt_browse_header_bar_toggle_search(GT_BROWSE_HEADER_BAR(priv->browse_header_bar));
else
{
GtkWidget* view = gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack));
if (view == priv->channels_view)
gt_channels_view_handle_event(GT_CHANNELS_VIEW(priv->channels_view), (GdkEvent*) evt);
else if (view == priv->games_view)
gt_games_view_handle_event(GT_GAMES_VIEW(priv->games_view), (GdkEvent*) evt);
else if (view == priv->follows_view)
gt_follows_view_handle_event(GT_FOLLOWS_VIEW(priv->follows_view), (GdkEvent* )evt);
}
}
return FALSE;
}
static void
gb_view_stack__notify_visible_child (GbViewStack *self,
GParamSpec *pspec,
GtkStack *stack)
{
GtkWidget *visible_child;
g_assert (GB_IS_VIEW_STACK (self));
g_assert (GTK_IS_STACK (stack));
visible_child = gtk_stack_get_visible_child (stack);
gb_view_stack_set_active_view (self, visible_child);
}
static void
libre_impuesto_sync_selection(LibreImpuesto * impuesto, const gchar * args)
{
GtkWindow * impuesto_window = libre_impuesto_get_active_window(impuesto);
GtkWidget * notebook, * switcher;
GtkWidget * page_child, * tree_view;
GtkTreeSelection * selection;
GtkTreeIter selected;
GtkTreePath * page_path, * tree_path;
GtkWidget * page_tree_view;
notebook = g_object_get_data ( G_OBJECT(impuesto_window), "notebook");
switcher = g_object_get_data ( G_OBJECT(impuesto_window), "switcher");
page_child = gtk_notebook_get_nth_page (GTK_NOTEBOOK(notebook),
gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook) ));
page_path = g_object_get_data ( G_OBJECT(page_child), "path" );
page_tree_view = g_object_get_data ( G_OBJECT(page_child), "tree-view" );
tree_view = gtk_stack_get_visible_child(gtk_stack_switcher_get_stack (GTK_STACK_SWITCHER(switcher)));
tree_view = gtk_bin_get_child(GTK_BIN(tree_view));
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
gtk_tree_selection_get_selected (selection, NULL, &selected);
if (page_path == NULL || page_tree_view == NULL ) {
gtk_tree_selection_unselect_all( selection );
return;
}
if ( gtk_tree_selection_count_selected_rows(selection) > 0 ) {
tree_path = gtk_tree_model_get_path (gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)), &selected);
if ( gtk_tree_path_compare( page_path, tree_path ) != 0 ) {
tree_view = g_object_get_data ( G_OBJECT(page_child), "tree-view" );
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
gtk_tree_selection_select_path ( selection, page_path );
tree_view = gtk_widget_get_parent ( GTK_WIDGET(tree_view) );
gtk_stack_set_visible_child (gtk_stack_switcher_get_stack (GTK_STACK_SWITCHER(switcher)), tree_view );
}
gtk_tree_path_free(tree_path);
}
else {
tree_view = g_object_get_data ( G_OBJECT(page_child), "tree-view" );
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
gtk_tree_selection_select_path ( selection, page_path );
tree_view = gtk_widget_get_parent ( GTK_WIDGET(tree_view) );
gtk_stack_set_visible_child (gtk_stack_switcher_get_stack (GTK_STACK_SWITCHER(switcher)), tree_view );
}
}
static void
get_property (GObject* obj,
guint prop,
GValue* val,
GParamSpec* pspec)
{
GtGamesView* self = GT_GAMES_VIEW(obj);
GtGamesViewPrivate* priv = gt_games_view_get_instance_private(self);
switch (prop)
{
case PROP_SEARCH_ACTIVE:
g_value_set_boolean(val, priv->search_active);
break;
case PROP_SHOWING_TOP_GAMES:
g_value_set_boolean(val, gtk_stack_get_visible_child(GTK_STACK(priv->games_stack)) == priv->top_container);
break;
case PROP_SHOWING_GAME_CHANNELS:
g_value_set_boolean(val, gtk_stack_get_visible_child(GTK_STACK(priv->games_stack)) == priv->game_container);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop, pspec);
}
}
static void
am_pm_stack_visible_child_changed_cb (CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv = self->priv;
AtkObject *am_pm_button_accessible;
GtkWidget *visible_label;
const gchar *visible_text;
am_pm_button_accessible = gtk_widget_get_accessible (W ("am_pm_button"));
if (am_pm_button_accessible == NULL)
return;
visible_label = gtk_stack_get_visible_child (GTK_STACK (priv->am_pm_stack));
visible_text = gtk_label_get_text (GTK_LABEL (visible_label));
atk_object_set_name (am_pm_button_accessible, visible_text);
}
static gchar *
ev_sidebar_get_visible_icon_name (EvSidebar *ev_sidebar)
{
GtkStack *stack;
GtkWidget *widget;
gchar *icon_name;
EvSidebarPrivate *priv = GET_PRIVATE (ev_sidebar);
stack = GTK_STACK (priv->stack);
widget = gtk_stack_get_visible_child (stack);
gtk_container_child_get (GTK_CONTAINER (stack), widget,
"icon-name", &icon_name,
NULL);
return icon_name;
}
static void
page_changed_cb (GtkWidget *stack, GParamSpec *pspec, gpointer data)
{
const gchar *name;
GtkWidget *page;
if (gtk_widget_in_destruction (stack))
return;
name = gtk_stack_get_visible_child_name (GTK_STACK (stack));
if (g_str_equal (name, "page3"))
{
page = gtk_stack_get_visible_child (GTK_STACK (stack));
set_needs_attention (GTK_WIDGET (page), FALSE);
}
}
static void
on_child_changed (GtkWidget *widget,
GParamSpec *pspec,
GtkStackSwitcher *self)
{
GtkWidget *child;
GtkWidget *button;
child = gtk_stack_get_visible_child (GTK_STACK (widget));
button = g_hash_table_lookup (self->priv->buttons, child);
if (button != NULL)
{
self->priv->in_child_changed = TRUE;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
self->priv->in_child_changed = FALSE;
}
}
static gboolean
am_pm_button_clicked (GtkWidget *button,
CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv = self->priv;
GtkWidget *visible_child;
visible_child = gtk_stack_get_visible_child (GTK_STACK (priv->am_pm_stack));
if (visible_child == priv->am_label)
gtk_stack_set_visible_child (GTK_STACK (priv->am_pm_stack), priv->pm_label);
else
gtk_stack_set_visible_child (GTK_STACK (priv->am_pm_stack), priv->am_label);
change_time (self);
return TRUE;
}
static void
pnl_tab_strip_stack_notify_visible_child (PnlTabStrip *self,
GParamSpec *pspec,
GtkStack *stack)
{
GtkWidget *visible;
g_assert (PNL_IS_TAB_STRIP (self));
g_assert (GTK_IS_STACK (stack));
visible = gtk_stack_get_visible_child (stack);
if (visible != NULL)
{
PnlTab *tab = g_object_get_data (G_OBJECT (visible), "PNL_TAB");
if (PNL_IS_TAB (tab))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tab), TRUE);
}
}
static void
change_time (CcDateTimePanel *panel)
{
CcDateTimePanelPrivate *priv = panel->priv;
guint h, m;
GDateTime *old_date;
old_date = priv->date;
h = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (W ("h_spinbutton")));
m = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (W ("m_spinbutton")));
if (priv->clock_format == G_DESKTOP_CLOCK_FORMAT_12H)
{
gboolean is_pm_time;
GtkWidget *visible_child;
visible_child = gtk_stack_get_visible_child (GTK_STACK (priv->am_pm_stack));
if (visible_child == priv->pm_label)
is_pm_time = TRUE;
else
is_pm_time = FALSE;
if (h == 12)
h = 0;
if (is_pm_time)
h += 12;
}
priv->date = g_date_time_new_local (g_date_time_get_year (old_date),
g_date_time_get_month (old_date),
g_date_time_get_day_of_month (old_date),
h, m,
g_date_time_get_second (old_date));
g_date_time_unref (old_date);
update_time (panel);
queue_set_datetime (panel);
}
static void
refresh_view_cb(GSimpleAction* action,
GVariant* arg,
gpointer udata)
{
GtWin* self = GT_WIN(udata);
GtWinPrivate* priv = gt_win_get_instance_private(self);
GtkWidget* visible_child = gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack));
if (visible_child == priv->channels_view)
gt_channels_view_refresh(GT_CHANNELS_VIEW(priv->channels_view));
else if (visible_child == priv->games_view)
gt_games_view_refresh(GT_GAMES_VIEW(priv->games_view));
else if (visible_child == priv->follows_view)
{
//TODO: Quick hack, turn this into a proper refresh function
if (gt_app_credentials_valid(main_app))
gt_follows_manager_load_from_twitch(main_app->fav_mgr);
else
gt_follows_manager_load_from_file(main_app->fav_mgr);
}
}
static gboolean
glade_previewer_stack_key_press_event (GtkWidget *window, GdkEventKey *event, GtkWidget *widget)
{
GtkWidget *child = gtk_stack_get_visible_child (GTK_STACK (widget));
GList *children, *node;
gboolean retval;
if (!child)
return FALSE;
children = gtk_container_get_children (GTK_CONTAINER (widget));
node = g_list_find (children, child);
if (node)
{
switch (event->keyval)
{
case GDK_KEY_Page_Up:
if (node->prev)
gtk_stack_set_visible_child (GTK_STACK (widget), node->prev->data);
retval = TRUE;
break;
case GDK_KEY_Page_Down:
if (node->next)
gtk_stack_set_visible_child (GTK_STACK (widget), node->next->data);
retval = TRUE;
break;
default:
retval = FALSE;
break;
}
}
g_list_free (children);
return retval;
}
