void
gt_games_view_show_type(GtGamesView* self, gint type)
{
GtGamesViewPrivate* priv = gt_games_view_get_instance_private(self);
switch (type)
{
case GT_GAMES_CONTAINER_TYPE_TOP:
gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->top_container);
priv->was_showing_game = FALSE;
break;
case GT_GAMES_CONTAINER_TYPE_SEARCH:
gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->search_container);
break;
case GT_CHANNELS_CONTAINER_TYPE_GAME:
gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->game_container);
priv->was_showing_game = TRUE;
break;
default:
break;
}
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_SHOWING_TOP_GAMES]);
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_SHOWING_GAME_CHANNELS]);
}
static void
set_mode (GisAccountPage *page,
UmAccountMode mode)
{
GisAccountPagePrivate *priv = gis_account_page_get_instance_private (page);
if (priv->mode == mode)
return;
priv->mode = mode;
gis_driver_set_account_mode (GIS_PAGE (page)->driver, mode);
switch (mode)
{
case UM_LOCAL:
gtk_stack_set_visible_child (GTK_STACK (priv->stack), priv->page_local);
gis_account_page_local_shown (GIS_ACCOUNT_PAGE_LOCAL (priv->page_local));
break;
case UM_ENTERPRISE:
gtk_stack_set_visible_child (GTK_STACK (priv->stack), priv->page_enterprise);
gis_account_page_enterprise_shown (GIS_ACCOUNT_PAGE_ENTERPRISE (priv->page_enterprise));
break;
default:
g_assert_not_reached ();
}
update_page_validation (page);
}
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
search_active_cb(GObject* source,
GParamSpec* pspec,
gpointer udata)
{
GtGamesView* self = GT_GAMES_VIEW(udata);
GtGamesViewPrivate* priv = gt_games_view_get_instance_private(self);
if (priv->search_active)
gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->search_container);
else
gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->top_container);
}
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
ide_frame_page_failed (IdeFrame *self,
GParamSpec *pspec,
IdePage *page)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
g_assert (IDE_IS_FRAME (self));
g_assert (IDE_IS_PAGE (page));
if (ide_page_get_failed (page))
gtk_stack_set_visible_child (priv->top_stack, GTK_WIDGET (priv->failed_state));
else
gtk_stack_set_visible_child (priv->top_stack, GTK_WIDGET (priv->stack));
}
void
gb_view_stack_add (GtkContainer *container,
GtkWidget *child)
{
GbViewStack *self = (GbViewStack *)container;
g_assert (GB_IS_VIEW_STACK (self));
if (GB_IS_VIEW (child))
{
GtkWidget *controls;
gtk_widget_set_sensitive (GTK_WIDGET (self->close_button), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (self->document_button), TRUE);
gtk_widget_set_visible (GTK_WIDGET (self->views_button), TRUE);
self->focus_history = g_list_prepend (self->focus_history, child);
controls = gb_view_get_controls (GB_VIEW (child));
if (controls)
gtk_container_add (GTK_CONTAINER (self->controls_stack), controls);
gtk_container_add (GTK_CONTAINER (self->stack), child);
gb_view_set_back_forward_list (GB_VIEW (child), self->back_forward_list);
gb_view_stack_add_list_row (self, GB_VIEW (child));
gtk_stack_set_visible_child (self->stack, child);
}
else
{
GTK_CONTAINER_CLASS (gb_view_stack_parent_class)->add (container, child);
}
}
void
gb_view_stack_remove (GbViewStack *self,
GbView *view)
{
GtkWidget *controls;
GtkWidget *focus_after_close = NULL;
g_assert (GB_IS_VIEW_STACK (self));
g_assert (GB_IS_VIEW (view));
focus_after_close = g_list_nth_data (self->focus_history, 1);
if (focus_after_close != NULL)
g_object_ref (focus_after_close);
gb_view_stack_remove_list_row (self, view);
self->focus_history = g_list_remove (self->focus_history, view);
controls = gb_view_get_controls (view);
if (controls)
gtk_container_remove (GTK_CONTAINER (self->controls_stack), controls);
gtk_container_remove (GTK_CONTAINER (self->stack), GTK_WIDGET (view));
if (focus_after_close != NULL)
{
gtk_stack_set_visible_child (self->stack, focus_after_close);
gtk_widget_grab_focus (GTK_WIDGET (focus_after_close));
g_clear_object (&focus_after_close);
}
else
g_signal_emit (self, gSignals [EMPTY], 0);
}
static void
updated_database_cb (gpointer data, gpointer user_data)
{
FsearchApplicationWindow *win = (FsearchApplicationWindow *) user_data;
g_assert (FSEARCH_WINDOW_IS_WINDOW (win));
hide_overlays (win);
update_statusbar (win, "");
fsearch_application_window_update_search (win);
gtk_spinner_stop (GTK_SPINNER (win->database_spinner));
gtk_stack_set_visible_child (GTK_STACK (win->database_stack), win->database_box2);
Database *db = fsearch_application_get_db (FSEARCH_APPLICATION_DEFAULT);
uint32_t num_items = db_get_num_entries (db);
gchar db_text[100] = "";
snprintf (db_text, sizeof (db_text), _("%'d Items"), num_items);
gtk_label_set_text (GTK_LABEL (win->database_label), db_text);
time_t timestamp = db_get_timestamp (db);
strftime (db_text, sizeof(db_text),
"Last Updated: %Y-%m-%d %H:%M", //"%Y-%m-%d %H:%M",
localtime (×tamp));
gtk_widget_set_tooltip_text (win->database_toggle_button, db_text);
}
static void
show_add_device_view(AccountDevicesTab *view)
{
g_return_if_fail(IS_ACCOUNT_DEVICES_TAB(view));
AccountDevicesTabPrivate *priv = ACCOUNT_DEVICES_TAB_GET_PRIVATE(view);
gtk_stack_set_visible_child(GTK_STACK(priv->stack_account_devices), priv->add_device);
}
static void guides_presets_set_visibility(dt_lib_live_view_t *lib, int which)
{
if(which == 0)
{
gtk_widget_set_no_show_all(lib->guides_widgets, TRUE);
gtk_widget_hide(lib->guides_widgets);
gtk_widget_set_no_show_all(lib->flip_guides, TRUE);
gtk_widget_hide(lib->flip_guides);
}
else
{
GtkWidget *widget = g_list_nth_data(lib->guides_widgets_list, which - 1);
if(widget)
{
gtk_widget_set_no_show_all(lib->guides_widgets, FALSE);
gtk_widget_show_all(lib->guides_widgets);
gtk_stack_set_visible_child(GTK_STACK(lib->guides_widgets), widget);
}
else
{
gtk_widget_set_no_show_all(lib->guides_widgets, TRUE);
gtk_widget_hide(lib->guides_widgets);
}
gtk_widget_set_no_show_all(lib->flip_guides, FALSE);
gtk_widget_show_all(lib->flip_guides);
}
// TODO: add a support_flip flag to guides to hide the flip gui?
}
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 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
set_vertical_labels (GcalEventWidget *self,
gboolean vertical)
{
if (self->vertical_labels == vertical)
return;
gtk_stack_set_visible_child (GTK_STACK (self->stack), vertical ? self->vertical_grid : self->horizontal_grid);
self->vertical_labels = vertical;
}
static void
settings_clicked(G_GNUC_UNUSED GtkButton *button, RingMainWindow *win)
{
g_return_if_fail(IS_RING_MAIN_WINDOW(win));
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
/* check which view to show */
if (!priv->show_settings) {
/* show the settings */
/* make sure we are not showing a call view so we don't have more than one clutter stage at a time */
selection_changed(QModelIndex(), win);
/* show settings */
gtk_image_set_from_icon_name(GTK_IMAGE(priv->image_settings), "emblem-ok-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_widget_show(priv->hbox_settings);
/* make sure to start preview if we're showing the video settings */
if (priv->last_settings_view == priv->media_settings_view)
media_settings_view_show_preview(MEDIA_SETTINGS_VIEW(priv->media_settings_view), TRUE);
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_UP);
gtk_stack_set_visible_child(GTK_STACK(priv->stack_main_view), priv->last_settings_view);
priv->show_settings = TRUE;
} else {
/* hide the settings */
priv->show_settings = FALSE;
/* show working dialog in case save operation takes time */
GtkWidget *working = ring_dialog_working(GTK_WIDGET(win), NULL);
gtk_window_present(GTK_WINDOW(working));
/* now save after the time it takes to transition back to the call view (400ms)
* the save doesn't happen before the "working" dialog is presented
* the timeout function should destroy the "working" dialog when done saving
*/
g_timeout_add_full(G_PRIORITY_DEFAULT, 400, (GSourceFunc)save_accounts, working, NULL);
/* show calls */
gtk_image_set_from_icon_name(GTK_IMAGE(priv->image_settings), "emblem-system-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_widget_hide(priv->hbox_settings);
/* make sure video preview is stopped, in case it was started */
media_settings_view_show_preview(MEDIA_SETTINGS_VIEW(priv->media_settings_view), FALSE);
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN);
gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), CALL_VIEW_NAME);
/* show the view which was selected previously */
selection_changed(RecentModel::instance().selectionModel()->currentIndex(), win);
}
}
static void
gtk_shortcuts_window__list_box__row_activated (GtkShortcutsWindow *self,
GtkListBoxRow *row,
GtkListBox *list_box)
{
GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
GtkWidget *section;
section = g_object_get_data (G_OBJECT (row), "gtk-shortcuts-section");
gtk_stack_set_visible_child (priv->stack, section);
gtk_widget_hide (GTK_WIDGET (priv->popover));
}
/**
* ide_frame_set_visible_child:
* @self: a #IdeFrame
*
* Sets the current page for the stack.
*
* Since: 3.32
*/
void
ide_frame_set_visible_child (IdeFrame *self,
IdePage *page)
{
IdeFramePrivate *priv = ide_frame_get_instance_private (self);
g_return_if_fail (IDE_IS_FRAME (self));
g_return_if_fail (IDE_IS_PAGE (page));
g_return_if_fail (gtk_widget_get_parent (GTK_WIDGET (page)) == (GtkWidget *)priv->stack);
gtk_stack_set_visible_child (priv->stack, GTK_WIDGET (page));
}
static void
on_button_clicked (GtkWidget *widget,
GtkStackSwitcher *self)
{
GtkWidget *child;
if (!self->priv->in_child_changed)
{
child = g_object_get_data (G_OBJECT (widget), "stack-child");
gtk_stack_set_visible_child (self->priv->stack, child);
}
}
static void
update_database_cb (gpointer data, gpointer user_data)
{
FsearchApplicationWindow *win = (FsearchApplicationWindow *) user_data;
g_assert (FSEARCH_WINDOW_IS_WINDOW (win));
show_overlay (win, DATABASE_UPDATING_OVERLAY);
gtk_stack_set_visible_child (GTK_STACK (win->database_stack), win->database_box1);
gtk_spinner_start (GTK_SPINNER (win->database_spinner));
gchar db_text[100] = "";
snprintf (db_text, sizeof (db_text), _("Loading Database..."));
gtk_label_set_text (GTK_LABEL (win->database_label), db_text);
}
static void
set_tab_state (GSimpleAction *action,
GVariant *state,
gpointer user_data)
{
PnlTabStrip *self = user_data;
PnlTabStripPrivate *priv = pnl_tab_strip_get_instance_private (self);
PnlTab *tab = NULL;
const GList *iter;
GList *list;
gint stateval;
g_assert (G_IS_SIMPLE_ACTION (action));
g_assert (PNL_IS_TAB_STRIP (self));
g_assert (state != NULL);
g_assert (g_variant_is_of_type (state, G_VARIANT_TYPE_INT32));
g_simple_action_set_state (action, state);
stateval = g_variant_get_int32 (state);
list = gtk_container_get_children (GTK_CONTAINER (priv->stack));
for (iter = list; iter != NULL; iter = iter->next)
{
GtkWidget *child = iter->data;
gint position = 0;
gtk_container_child_get (GTK_CONTAINER (priv->stack), GTK_WIDGET (child),
"position", &position,
NULL);
if (position == stateval)
{
tab = g_object_get_data (G_OBJECT (child), "PNL_TAB");
gtk_stack_set_visible_child (priv->stack, child);
break;
}
}
/*
* When clicking an active toggle button, we get the state callback but then
* the toggle button disables the checked state. So ensure it stays on by
* manually setting the state.
*/
if (PNL_IS_TAB (tab))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tab), TRUE);
g_list_free (list);
}
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;
}
static void
gtk_shortcuts_window_add_section (GtkShortcutsWindow *self,
GtkShortcutsSection *section)
{
GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
GtkListBoxRow *row;
gchar *title;
gchar *name;
const gchar *visible_section;
GtkWidget *label;
gtk_container_foreach (GTK_CONTAINER (section), gtk_shortcuts_window_add_search_item, self);
g_object_get (section,
"section-name", &name,
"title", &title,
NULL);
g_signal_connect (section, "notify", G_CALLBACK (section_notify_cb), self);
if (name == NULL)
name = g_strdup ("shortcuts");
gtk_stack_add_titled (priv->stack, GTK_WIDGET (section), name, title);
visible_section = gtk_stack_get_visible_child_name (priv->stack);
if (strcmp (visible_section, "internal-search") == 0 ||
(priv->initial_section && strcmp (priv->initial_section, visible_section) == 0))
gtk_stack_set_visible_child (priv->stack, GTK_WIDGET (section));
row = g_object_new (GTK_TYPE_LIST_BOX_ROW,
"visible", TRUE,
NULL);
g_object_set_data (G_OBJECT (row), "gtk-shortcuts-section", section);
label = g_object_new (GTK_TYPE_LABEL,
"margin", 6,
"label", title,
"xalign", 0.5f,
"visible", TRUE,
NULL);
g_object_set_data (G_OBJECT (section), "gtk-shortcuts-title", label);
gtk_container_add (GTK_CONTAINER (row), GTK_WIDGET (label));
gtk_container_add (GTK_CONTAINER (priv->list_box), GTK_WIDGET (row));
update_title_stack (self);
g_free (name);
g_free (title);
}
static void
gtk_shortcuts_window_set_section_name (GtkShortcutsWindow *self,
const gchar *section_name)
{
GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
GtkWidget *section = NULL;
g_free (priv->initial_section);
priv->initial_section = g_strdup (section_name);
if (!section_name)
section = gtk_stack_get_child_by_name (priv->stack, section_name);
if (section)
gtk_stack_set_visible_child (priv->stack, section);
}
void
ev_sidebar_set_page (EvSidebar *ev_sidebar,
GtkWidget *main_widget)
{
EvSidebarPrivate *priv;
g_return_if_fail (EV_IS_SIDEBAR (ev_sidebar));
g_return_if_fail (GTK_IS_WIDGET (main_widget));
priv = GET_PRIVATE (ev_sidebar);
gtk_stack_set_visible_child (GTK_STACK (priv->stack),
main_widget);
g_object_notify (G_OBJECT (ev_sidebar), "current-page");
}
static void
open_submenu (GtkWidget *button,
gpointer data)
{
GtkMenuTrackerItem *item = data;
GtkWidget *stack;
GtkWidget *child;
GtkWidget *focus;
if (gtk_menu_tracker_item_get_should_request_show (item))
gtk_menu_tracker_item_request_submenu_shown (item, TRUE);
focus = GTK_WIDGET (g_object_get_data (G_OBJECT (button), "focus"));
get_ancestors (focus, GTK_TYPE_STACK, &stack, &child);
gtk_stack_set_visible_child (GTK_STACK (stack), child);
gtk_widget_grab_focus (focus);
}
static void
gth_window_real_set_current_page (GthWindow *window,
int page)
{
int i;
if (window->priv->current_page == page)
return;
window->priv->current_page = page;
gtk_stack_set_visible_child (GTK_STACK (window->priv->stack), window->priv->pages[page]);
for (i = 0; i < window->priv->n_pages; i++)
if (i == page)
gtk_widget_show (window->priv->contents[i]);
else
gtk_widget_hide (window->priv->contents[i]);
}
static void
init_statusbar (FsearchApplicationWindow *self)
{
g_assert (FSEARCH_WINDOW_IS_WINDOW (self));
gtk_spinner_stop (GTK_SPINNER (self->database_spinner));
gtk_stack_set_visible_child (GTK_STACK (self->database_stack), self->database_box2);
Database *db = fsearch_application_get_db (FSEARCH_APPLICATION_DEFAULT);
uint32_t num_items = 0;
if (db) {
num_items = db_get_num_entries (db);
}
gchar db_text[100] = "";
snprintf (db_text, sizeof (db_text), _("%'d Items"), num_items);
gtk_label_set_text (GTK_LABEL (self->database_label), db_text);
}
static void
build_tab_view(AccountDevicesTab *view)
{
g_return_if_fail(IS_ACCOUNT_DEVICES_TAB(view));
AccountDevicesTabPrivate *priv = ACCOUNT_DEVICES_TAB_GET_PRIVATE(view);
g_signal_connect_swapped(priv->button_add_device, "clicked", G_CALLBACK(show_add_device_view), view);
g_signal_connect_swapped(priv->button_add_device_cancel, "clicked", G_CALLBACK(show_manage_devices_view), view);
g_signal_connect(priv->button_export_on_the_ring, "clicked", G_CALLBACK(export_on_the_ring_clicked), view);
g_signal_connect_swapped(priv->button_generated_pin_ok, "clicked", G_CALLBACK(show_manage_devices_view), view);
g_signal_connect_swapped(priv->button_export_on_ring_error_ok, "clicked", G_CALLBACK(show_add_device_view), view);
gtk_label_set_text(GTK_LABEL(priv->label_device_id), priv->account->deviceId().toUtf8().constData());
/* treeview_devices */
auto *devices_model = gtk_q_tree_model_new(
(QAbstractItemModel*) priv->account->ringDeviceModel(),
2,
RingDevice::Column::Name, Qt::DisplayRole, G_TYPE_STRING,
RingDevice::Column::Id, Qt::DisplayRole, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->treeview_devices), GTK_TREE_MODEL(devices_model));
GtkCellRenderer* renderer;
GtkTreeViewColumn* column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(C_("Device Name Column", "Name"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview_devices), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(C_("Device ID Column", "ID"), renderer, "text", 1, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview_devices), column);
/* Show manage-devices view */
gtk_stack_set_visible_child(GTK_STACK(priv->stack_account_devices), priv->manage_devices);
}
static void
ide_workbench_show_parents (GtkWidget *widget)
{
GtkWidget *parent;
g_assert (GTK_IS_WIDGET (widget));
parent = gtk_widget_get_parent (widget);
if (IDE_IS_LAYOUT_PANE (widget))
pnl_dock_revealer_set_reveal_child (PNL_DOCK_REVEALER (widget), TRUE);
if (IDE_IS_PERSPECTIVE (widget))
ide_workbench_set_visible_perspective (ide_widget_get_workbench (widget),
IDE_PERSPECTIVE (widget));
if (GTK_IS_STACK (parent))
gtk_stack_set_visible_child (GTK_STACK (parent), widget);
if (parent != NULL)
ide_workbench_show_parents (parent);
}
static void
debug_manager_notify_debugger (IdeDebuggerEditorAddin *self,
GParamSpec *pspec,
IdeDebugManager *debug_manager)
{
IdeDebugger *debugger;
IdeWorkspace *workspace;
g_assert (IDE_IS_DEBUGGER_EDITOR_ADDIN (self));
g_assert (IDE_IS_DEBUG_MANAGER (debug_manager));
if (!gtk_widget_get_visible (GTK_WIDGET (self->panel)))
{
GtkWidget *stack = gtk_widget_get_parent (GTK_WIDGET (self->panel));
gtk_widget_show (GTK_WIDGET (self->panel));
if (GTK_IS_STACK (stack))
gtk_stack_set_visible_child (GTK_STACK (stack), GTK_WIDGET (self->panel));
}
debugger = ide_debug_manager_get_debugger (debug_manager);
if ((workspace = ide_widget_get_workspace (GTK_WIDGET (self->editor))))
gtk_widget_insert_action_group (GTK_WIDGET (workspace),
"debugger",
G_ACTION_GROUP (debugger));
ide_debugger_breakpoints_view_set_debugger (self->breakpoints_view, debugger);
ide_debugger_locals_view_set_debugger (self->locals_view, debugger);
ide_debugger_libraries_view_set_debugger (self->libraries_view, debugger);
ide_debugger_registers_view_set_debugger (self->registers_view, debugger);
ide_debugger_threads_view_set_debugger (self->threads_view, debugger);
dzl_signal_group_set_target (self->debugger_signals, debugger);
}
