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 GtkWidget* main_window() {
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Switcher");
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_add(GTK_CONTAINER(window), box);
// Stack
GtkWidget* main_area = gtk_stack_new();
gtk_stack_set_transition_type(GTK_STACK(main_area),
GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
gtk_stack_set_transition_duration(GTK_STACK(main_area), 2000);
// Checkbox
GtkWidget* check_button =
gtk_check_button_new_with_label("Do not fn check me");
gtk_stack_add_titled(GTK_STACK(main_area), check_button, "check_name",
"Check Box");
// Label
GtkWidget* label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), "<big>OMG this text is huge!</big>");
gtk_stack_add_titled(GTK_STACK(main_area), label, "label_name", "Big Label");
// StackSwitcher
GtkWidget* stack_switcher = gtk_stack_switcher_new();
gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(stack_switcher),
GTK_STACK(main_area));
gtk_box_pack_start(GTK_BOX(box), stack_switcher, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), main_area, TRUE, TRUE, 0);
return window;
}
static void
gth_window_set_n_pages (GthWindow *self,
int n_pages)
{
int i;
if (self->priv->n_pages != 0) {
g_critical ("The number of pages of a GthWindow can be set only once.");
return;
}
self->priv->n_pages = n_pages;
self->priv->overlay = gtk_overlay_new ();
gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->overlay), "window-overlay");
gtk_widget_show (self->priv->overlay);
gtk_container_add (GTK_CONTAINER (self), self->priv->overlay);
g_signal_connect (self->priv->overlay,
"get-child-position",
G_CALLBACK (overlay_get_child_position_cb),
self);
self->priv->grid = gtk_grid_new ();
gtk_widget_show (self->priv->grid);
gtk_container_add (GTK_CONTAINER (self->priv->overlay), self->priv->grid);
self->priv->stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (self->priv->stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE);
gtk_widget_show (self->priv->stack);
gtk_grid_attach (GTK_GRID (self->priv->grid),
self->priv->stack,
0, 2,
1, 1);
self->priv->toolbars = g_new0 (GtkWidget *, n_pages);
self->priv->contents = g_new0 (GtkWidget *, n_pages);
self->priv->pages = g_new0 (GtkWidget *, n_pages);
for (i = 0; i < n_pages; i++) {
GtkWidget *page;
self->priv->pages[i] = page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (page);
gtk_container_add (GTK_CONTAINER (self->priv->stack), page);
self->priv->toolbars[i] = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (self->priv->toolbars[i]);
gtk_box_pack_start (GTK_BOX (page), self->priv->toolbars[i], FALSE, FALSE, 0);
self->priv->contents[i] = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_hide (self->priv->contents[i]);
gtk_box_pack_start (GTK_BOX (page), self->priv->contents[i], TRUE, TRUE, 0);
}
self->priv->window_size = g_new0 (GthWindowSize, n_pages);
for (i = 0; i < n_pages; i++)
self->priv->window_size[i].saved = FALSE;
}
static void
show_general_settings(GtkToggleButton *navbutton, RingMainWindow *win)
{
g_return_if_fail(IS_RING_MAIN_WINDOW(win));
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
if (gtk_toggle_button_get_active(navbutton)) {
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT);
gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), GENERAL_SETTINGS_VIEW_NAME);
priv->last_settings_view = priv->general_settings_view;
}
}
static void
ekiga_window_init_gui (EkigaWindow *mw)
{
GtkWidget *window_vbox;
// FIXME ??? ekiga-settings.h
gtk_window_set_title (GTK_WINDOW (mw), _("Ekiga Softphone"));
gtk_window_set_icon_name (GTK_WINDOW (mw), PACKAGE_NAME);
window_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (mw), window_vbox);
gtk_widget_show_all (window_vbox);
/* The info bar */
mw->priv->info_bar = gm_info_bar_new ();
gtk_box_pack_start (GTK_BOX (window_vbox),
GTK_WIDGET (mw->priv->info_bar), TRUE, TRUE, 0);
/* The main stack */
mw->priv->main_stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (mw->priv->main_stack),
GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT);
/* The main menu */
ekiga_window_init_menu (mw);
/* The actions toolbar */
ekiga_window_init_actions_toolbar (mw);
/* The status toolbar */
ekiga_window_init_status_toolbar (mw);
gtk_widget_show_all (mw->priv->status_toolbar);
gtk_box_pack_start (GTK_BOX (window_vbox), mw->priv->status_toolbar,
false, false, 0);
/* The stack pages */
ekiga_window_init_contact_list (mw);
ekiga_window_init_dialpad (mw);
ekiga_window_init_history (mw);
gtk_widget_show_all (mw->priv->main_stack);
gtk_box_pack_start (GTK_BOX (window_vbox), mw->priv->main_stack,
true, true, 0);
/* Realize */
gtk_widget_realize (GTK_WIDGET (mw));
/* Update the widget when the user changes the configuration */
g_settings_bind (mw->priv->user_interface_settings->get_g_settings (),
"panel-section", mw->priv->main_stack,
"visible-child-name", G_SETTINGS_BIND_DEFAULT);
}
static void
account_creation_done_clicked(G_GNUC_UNUSED GtkButton *button, RingMainWindow *win)
{
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
QObject::disconnect(priv->hash_updated);
/* show the call view */
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT);
gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), CALL_VIEW_NAME);
/* show the settings button*/
gtk_widget_show(priv->ring_settings);
}
void
ManageDB_sidebar(GtkApplication *application){
GtkWidget *sidebar;
GtkWidget *stack;
GtkWidget *box;
GtkWidget *widget;
GtkWidget *header;
windowdb = gtk_application_window_new (application);
header = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(header), TRUE);
gtk_window_set_titlebar (GTK_WINDOW(windowdb), header);
gtk_window_set_title(GTK_WINDOW(windowdb), "Gerenciamento do Banco de Dados");
gtk_window_set_default_size (GTK_WINDOW (windowdb), 500, 500);
g_signal_connect (windowdb, "destroy",
G_CALLBACK (gtk_widget_destroyed), &windowdb);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
sidebar = gtk_stack_sidebar_new ();
gtk_box_pack_start (GTK_BOX (box), sidebar, FALSE, FALSE, 0);
stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
/* Separator between sidebar and stack */
widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX(box), widget, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), stack, TRUE, TRUE, 0);
/* Precisamos adicionar as ações... */
Welcome_side(widget, stack);
Create_side(widget, stack);
Backup_side(widget, stack);
Restore_side(widget, stack);
Delete_side(widget, stack);
Advanced_side(widget, stack);
gtk_container_add (GTK_CONTAINER (windowdb), box);
gtk_widget_show_all (windowdb);
}
static gboolean
create_ring_account(RingMainWindow *win)
{
g_return_val_if_fail(IS_RING_MAIN_WINDOW(win), G_SOURCE_REMOVE);
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
/* create account and set UPnP enabled, as its not by default in the daemon */
const gchar *alias = gtk_entry_get_text(GTK_ENTRY(priv->entry_alias));
Account *account = AccountModel::instance().add(alias, Account::Protocol::RING);
account->setDisplayName(alias); // set the display name to the same as the alias
account->setUpnpEnabled(TRUE);
/* wait for hash to be generated to show the next view */
priv->hash_updated = QObject::connect(
account,
&Account::changed,
[=] (Account *a) {
QString hash = a->username();
if (!hash.isEmpty()) {
/* set the hash */
gtk_entry_set_text(GTK_ENTRY(priv->entry_hash), hash.toUtf8().constData());
/* show the next accont creation view */
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT);
gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), CREATE_ACCOUNT_2_VIEW_NAME);
/* select the hash text */
gtk_widget_grab_focus(priv->entry_hash);
gtk_editable_select_region(GTK_EDITABLE(priv->entry_hash), 0, -1);
}
}
);
account->performAction(Account::EditAction::SAVE);
return G_SOURCE_REMOVE;
}
static void
nemo_toolbar_constructed (GObject *obj)
{
NemoToolbar *self = NEMO_TOOLBAR (obj);
GtkWidget *toolbar;
GtkWidget *hbox;
GtkToolItem *tool_box;
GtkWidget *box;
GtkStyleContext *context;
G_OBJECT_CLASS (nemo_toolbar_parent_class)->constructed (obj);
gtk_style_context_set_junction_sides (gtk_widget_get_style_context (GTK_WIDGET (self)),
GTK_JUNCTION_BOTTOM);
self->priv->show_location_entry = g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_LOCATION_ENTRY);
/* add the UI */
self->priv->ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (self->priv->ui_manager, self->priv->action_group, 0);
toolbar = gtk_toolbar_new ();
self->priv->toolbar = toolbar;
gtk_box_pack_start (GTK_BOX (self), self->priv->toolbar, TRUE, TRUE, 0);
context = gtk_widget_get_style_context (GTK_WIDGET(toolbar));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
/* Back/Forward/Up */
self->priv->navigation_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->previous_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_BACK);
gtk_container_add (GTK_CONTAINER (box), self->priv->previous_button);
self->priv->next_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_FORWARD);
gtk_container_add (GTK_CONTAINER (box), self->priv->next_button);
self->priv->up_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_UP);
gtk_container_add (GTK_CONTAINER (box), self->priv->up_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (self->priv->navigation_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->navigation_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->navigation_box));
gtk_widget_set_margin_right (GTK_WIDGET (self->priv->navigation_box), 6);
/* Refresh */
self->priv->refresh_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->refresh_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_RELOAD);
gtk_container_add (GTK_CONTAINER (box), self->priv->refresh_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_container_add (GTK_CONTAINER (self->priv->refresh_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->refresh_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->refresh_box));
gtk_widget_set_margin_right (GTK_WIDGET (self->priv->refresh_box), 6);
/* Home/Computer */
self->priv->location_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->home_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_HOME);
gtk_container_add (GTK_CONTAINER (box), self->priv->home_button);
self->priv->computer_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_COMPUTER);
gtk_container_add (GTK_CONTAINER (box), self->priv->computer_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (self->priv->location_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->location_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->location_box));
gtk_widget_set_margin_right (GTK_WIDGET (self->priv->location_box), 6);
/* Container to hold the location and pathbars */
self->priv->stack = gtk_stack_new();
gtk_stack_set_transition_type (GTK_STACK (self->priv->stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE);
gtk_stack_set_transition_duration (GTK_STACK (self->priv->stack), 150);
/* Regular Path Bar */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (self->priv->stack), TRUE, TRUE, 0);
self->priv->path_bar = g_object_new (NEMO_TYPE_PATH_BAR, NULL);
gtk_stack_add_named(GTK_STACK (self->priv->stack), GTK_WIDGET (self->priv->path_bar), "path_bar");
/* Entry-Like Location Bar */
self->priv->location_bar = nemo_location_bar_new ();
gtk_stack_add_named(GTK_STACK (self->priv->stack), GTK_WIDGET (self->priv->location_bar), "location_bar");
gtk_widget_show_all (hbox);
tool_box = gtk_tool_item_new ();
gtk_tool_item_set_expand (tool_box, TRUE);
gtk_container_add (GTK_CONTAINER (tool_box), hbox);
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (tool_box));
gtk_widget_show (GTK_WIDGET (tool_box));
/* Search/Open in Terminal/New Folder/Toggle Location */
self->priv->tools_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->toggle_location_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_TOGGLE_LOCATION);
gtk_container_add (GTK_CONTAINER (box), self->priv->toggle_location_button);
self->priv->open_terminal_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_OPEN_IN_TERMINAL);
gtk_container_add (GTK_CONTAINER (box), self->priv->open_terminal_button);
self->priv->new_folder_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_NEW_FOLDER);
gtk_container_add (GTK_CONTAINER (box), self->priv->new_folder_button);
self->priv->search_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_SEARCH);
gtk_container_add (GTK_CONTAINER (box), self->priv->search_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (self->priv->tools_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->tools_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->tools_box));
gtk_widget_set_margin_left (GTK_WIDGET (self->priv->tools_box), 6);
setup_root_info_bar (self);
/* View Select */
self->priv->view_box = gtk_tool_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
self->priv->icon_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_ICON_VIEW);
gtk_container_add (GTK_CONTAINER (box), self->priv->icon_view_button);
self->priv->list_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_LIST_VIEW);
gtk_container_add (GTK_CONTAINER (box), self->priv->list_view_button);
self->priv->compact_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_COMPACT_VIEW);
gtk_container_add (GTK_CONTAINER (box), self->priv->compact_view_button);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED);
gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED);
gtk_container_add (GTK_CONTAINER (self->priv->view_box), GTK_WIDGET (box));
gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->view_box));
gtk_widget_show_all (GTK_WIDGET (self->priv->view_box));
gtk_widget_set_margin_left (GTK_WIDGET (self->priv->view_box), 6);
/* nemo patch */
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_PREVIOUS_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_NEXT_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_UP_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_EDIT_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_RELOAD_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_HOME_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_COMPUTER_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_SEARCH_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_NEW_FOLDER_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_OPEN_IN_TERMINAL_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_ICON_VIEW_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_LIST_VIEW_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
g_signal_connect_swapped (nemo_preferences,
"changed::" NEMO_PREFERENCES_SHOW_COMPACT_VIEW_ICON_TOOLBAR,
G_CALLBACK (toolbar_update_appearance), self);
toolbar_update_appearance (self);
}
static void
gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass)
{
GtkWidget *grid;
GtkWidget *label;
GtkWidget *exp;
gchar *str;
g_return_if_fail (GDAUI_IS_DSN_EDITOR (config));
gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL);
/* allocate private structure */
config->priv = g_new0 (GdauiDsnEditorPrivate, 1);
config->priv->dsn_info = g_new0 (GdaDsnInfo, 1);
config->priv->no_change_signal = TRUE;
/* data source's name and icon */
GtkWidget *hbox_header;
hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6);
config->priv->icon = gtk_image_new ();
gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE);
gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0);
config->priv->wname = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10);
GtkWidget *menu_button;
menu_button = gtk_menu_button_new ();
gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0);
GtkWidget *menu_icon;
menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon);
GMenu *smenu;
smenu = g_menu_new ();
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu));
GMenuItem *mitem;
mitem = g_menu_item_new ("Test data source", "win.DSNTest");
g_menu_insert_item (smenu, -1, mitem);
mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset");
g_menu_insert_item (smenu, -1, mitem);
mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy");
g_menu_insert_item (smenu, -1, mitem);
GtkWindow *win;
win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ()));
g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config);
/* stack in a scrolled window */
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_vexpand (sw, TRUE);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6);
/* Stack */
config->priv->stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
gtk_container_add (GTK_CONTAINER (sw), config->priv->stack);
/* set up widgets */
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_widget_show (grid);
label = gtk_label_new_with_mnemonic (_("_System wide data source:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
config->priv->is_system = gtk_check_button_new ();
gtk_widget_show (config->priv->is_system);
g_signal_connect (G_OBJECT (config->priv->is_system), "toggled",
G_CALLBACK (field_toggled_cb), config);
gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1);
str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:"));
label = gtk_label_new ("");
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str);
g_free (str);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
config->priv->wprovider = gdaui_provider_selector_new ();
gtk_widget_set_hexpand (config->priv->wprovider, TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider);
gtk_widget_show (config->priv->wprovider);
g_signal_connect (G_OBJECT (config->priv->wprovider), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1);
label = gtk_label_new_with_mnemonic (_("_Description:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
config->priv->wdesc = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc);
gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE);
gtk_widget_set_vexpand (config->priv->wdesc, TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc);
g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1);
config->priv->warning = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (config->priv->warning),
_("<span foreground='red'>The database provider used by this data source is not available,\n"
"editing the data source's attributes is disabled</span>"));
gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (config->priv->warning, TRUE);
g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL);
gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER);
gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE);
gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1);
gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION);
/* connection's spec */
config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider
(GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)));
g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_widget_show (config->priv->dsn_spec);
gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS);
/* connection's authentication */
config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider
(GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)));
g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_widget_show (config->priv->dsn_auth);
gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH);
config->priv->no_change_signal = FALSE;
}
static GtkWidget*
create_starter_widget (StarterPlugin* plugin)
{
GError *error;
GtkWidget *stack;
GtkWidget *switcher;
GtkWidget *starter_box;
GtkWidget *switcher_box;
GtkWidget *actions_frame;
GtkWidget *actions_listbox;
GtkWidget *recent_projects_box;
GtkWidget *recent_listbox;
GtkBuilder *builder;
GtkWidget *button;
error = NULL;
builder = gtk_builder_new ();
if (!gtk_builder_add_from_resource (builder, "/org/gnome/anjuta/ui/starter.ui", &error))
{
DEBUG_PRINT ("Could not load starter.ui! %s", error->message);
g_error_free (error);
}
else
{
/* Manually assembling stack and switcher because they are not available in glade yet */
switcher = gtk_stack_switcher_new ();
stack = gtk_stack_new ();
gtk_stack_switcher_set_stack (switcher, stack);
gtk_stack_set_transition_type (stack, GTK_STACK_TRANSITION_TYPE_CROSSFADE);
gtk_stack_set_transition_duration (stack, TRANSITION_TIME);
starter_box = GTK_WIDGET (gtk_builder_get_object (builder, STARTER_BOX));
switcher_box = GTK_WIDGET (gtk_builder_get_object (builder, SWITCHER_BOX));
gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (starter_box)), starter_box);
g_object_ref (starter_box);
gtk_box_pack_start (switcher_box, switcher, FALSE, FALSE, 0);
gtk_box_pack_start (starter_box, stack, FALSE, FALSE, 0);
gtk_widget_show_all (starter_box);
actions_listbox = GTK_WIDGET (gtk_builder_get_object (builder, ACTIONS_LISTBOX));
gtk_list_box_set_header_func (GTK_LIST_BOX (actions_listbox), add_action_separators, NULL, NULL);
actions_frame = GTK_WIDGET (gtk_builder_get_object (builder, ACTIONS_FRAME));
gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (actions_frame)), actions_frame);
g_object_ref (actions_frame);
gtk_stack_add_titled (stack, actions_frame, ACTIONS_ID, "Actions");
recent_projects_box = GTK_WIDGET (gtk_builder_get_object (builder, RECENT_PROJECTS_BOX));
gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (recent_projects_box)), recent_projects_box);
g_object_ref (recent_projects_box);
recent_listbox = GTK_WIDGET (gtk_builder_get_object (builder, RECENT_LISTBOX));
refresh_recent_project_view (GTK_LIST_BOX (recent_listbox));
gtk_stack_add_titled (stack, recent_projects_box, RECENT_PROJECTS_ID, "Recent Projects");
button = GTK_WIDGET (gtk_builder_get_object (builder, REMOVE_PROJECT_BUTTON));
g_signal_connect_object (G_OBJECT (button), "clicked",
G_CALLBACK (on_remove_project_clicked), recent_listbox, G_CONNECT_AFTER);
gtk_builder_connect_signals (builder, plugin);
}
g_object_unref (builder);
return starter_box;
}
GtkWidget *
do_sidebar (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
GtkWidget *sidebar;
GtkWidget *stack;
GtkWidget *box;
GtkWidget *widget;
GtkWidget *header;
const gchar* pages[] = {
"Welcome to GTK+",
"GtkStackSidebar Widget",
"Automatic navigation",
"Consistent appearance",
"Scrolling",
"Page 6",
"Page 7",
"Page 8",
"Page 9",
NULL
};
const gchar *c = NULL;
guint i;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
gtk_widget_set_size_request (window, 500, 350);
header = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(header), TRUE);
gtk_window_set_titlebar (GTK_WINDOW(window), header);
gtk_window_set_title (GTK_WINDOW(window), "Stack Sidebar");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
sidebar = gtk_stack_sidebar_new ();
gtk_box_pack_start (GTK_BOX (box), sidebar, FALSE, FALSE);
stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
/* Separator between sidebar and stack */
widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX(box), widget, FALSE, FALSE);
gtk_box_pack_start (GTK_BOX (box), stack, TRUE, TRUE);
for (i=0; (c = *(pages+i)) != NULL; i++ )
{
if (i == 0)
{
widget = gtk_image_new_from_icon_name ("help-about", GTK_ICON_SIZE_MENU);
gtk_image_set_pixel_size (GTK_IMAGE (widget), 256);
}
else
{
widget = gtk_label_new (c);
}
gtk_stack_add_named (GTK_STACK (stack), widget, c);
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", c, NULL);
}
gtk_container_add (GTK_CONTAINER (window), box);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
PocketvoxSetup* pocketvox_setup_new()
{
PocketvoxSetup *setup = (PocketvoxSetup *)g_object_new(TYPE_POCKETVOX_SETUP, NULL);
setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
PocketvoxSetupPrivate *priv = setup->priv;
bindtextdomain (GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
priv->settings = g_settings_new("org.pocketvox.config");
//Build the window
priv->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(priv->window), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_title(GTK_WINDOW(priv->window), "pocketvox-gtk");
gtk_window_set_default_size(GTK_WINDOW(priv->window), 500, 350);
gtk_window_set_icon_name(GTK_WINDOW(priv->window), "pocketvox");
gtk_container_set_border_width(GTK_CONTAINER(priv->window), 5);
g_signal_connect_swapped(priv->window, "delete-event", G_CALLBACK(pocketvox_setup_save_and_quit), setup);
GtkWidget *bar = gtk_header_bar_new();
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(priv->window), bar);
//add a vertical box
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(priv->window), box);
//a button for all
GtkWidget* button_notification = gtk_button_new_with_label(_("Notifications"));
GtkWidget* button_user = gtk_button_new_with_label(_("Users"));
GtkWidget* button_pocketsphinx = gtk_button_new_with_label(_("Pocketsphinx"));
GtkWidget* button_gstreamer = gtk_button_new_with_label(_("Gstreamer"));
gtk_widget_set_tooltip_text(button_notification, _("Display notifications parameters"));
gtk_widget_set_tooltip_text(button_user, _("Display user parameters"));
gtk_widget_set_tooltip_text(button_pocketsphinx, _("Display pocketsphinx parameters"));
gtk_widget_set_tooltip_text(button_gstreamer, _("Display gstreamer parameters"));
gtk_button_set_relief(GTK_BUTTON(button_notification), GTK_RELIEF_NONE);
gtk_button_set_relief(GTK_BUTTON(button_user), GTK_RELIEF_NONE);
gtk_button_set_relief(GTK_BUTTON(button_pocketsphinx), GTK_RELIEF_NONE);
gtk_button_set_relief(GTK_BUTTON(button_gstreamer), GTK_RELIEF_NONE);
GtkWidget *grid_button = gtk_grid_new();
gtk_grid_attach(GTK_GRID(grid_button), button_user, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid_button), button_notification, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid_button), button_pocketsphinx, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid_button), button_gstreamer, 0, 3, 1, 1);
GtkWidget* grid_notification = pocketvox_setup_get_notification_grid(setup);
GtkWidget* grid_user = pocketvox_setup_get_user_grid(setup);
GtkWidget* grid_pocketsphinx = pocketvox_setup_get_pocketsphinx_grid(setup);
GtkWidget* grid_gstreamer = pocketvox_setup_get_gstreamer_grid(setup);
//connect all signals (TODO)
g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_show), grid_notification);
g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx);
g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);
g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_show), grid_pocketsphinx);
g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);
g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_show), grid_user);
g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx);
g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);
g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx);
g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_show), grid_gstreamer);
//add
GtkWidget* gridBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(gridBox), grid_user, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(gridBox), grid_notification, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(gridBox), grid_pocketsphinx, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(gridBox), grid_gstreamer, TRUE, TRUE, 0);
GtkWidget* separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_widget_show(separator);
GtkWidget *hgridBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(hgridBox), grid_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hgridBox), separator, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hgridBox), gridBox, TRUE, TRUE, 0);
GtkWidget *stack = gtk_stack_new();
gtk_stack_set_transition_type(GTK_STACK(stack) , GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
gtk_stack_set_transition_duration(GTK_STACK(stack), 1000);
gtk_stack_add_titled(GTK_STACK(stack), hgridBox, "Setup", _("Configuration"));
GtkWidget* scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
//return void
pocketvox_setup_get_modules_grid(setup);
gtk_container_add(GTK_CONTAINER(scrolledWindow), priv->listBox);
gtk_widget_show_all(scrolledWindow);
gtk_stack_add_titled(GTK_STACK(stack), scrolledWindow, "Modules", _("Modules"));
//adding a task switcher
GtkWidget* stackSwitcher = gtk_stack_switcher_new();
gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(stackSwitcher), GTK_STACK(stack));
gtk_header_bar_set_custom_title(GTK_HEADER_BAR(bar), stackSwitcher);
GtkWidget *add_module_button = gtk_button_new_from_icon_name("gtk-new", GTK_ICON_SIZE_MENU);
GtkWidget *remove_module_button = gtk_button_new_from_icon_name("gtk-delete", GTK_ICON_SIZE_MENU);
gtk_button_set_relief(GTK_BUTTON(add_module_button), GTK_RELIEF_NONE);
gtk_button_set_relief(GTK_BUTTON(remove_module_button), GTK_RELIEF_NONE);
gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), add_module_button);
gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), remove_module_button);
g_signal_connect_swapped(remove_module_button, "clicked", G_CALLBACK(pocketvox_setup_remove_module), setup);
g_signal_connect_swapped(add_module_button, "clicked", G_CALLBACK(pocketvox_setup_add_module_callback), setup);
g_signal_connect_swapped(stack, "notify::visible-child", G_CALLBACK(pocketvox_stack_child_changed), add_module_button);
g_signal_connect_swapped(stack, "notify::visible-child", G_CALLBACK(pocketvox_stack_child_changed), remove_module_button);
//add them to the vbox
gtk_box_pack_start(GTK_BOX(box), stack, TRUE, TRUE, 0);
gtk_widget_show(grid_user);
gtk_widget_hide(grid_notification);
gtk_widget_hide(grid_pocketsphinx);
gtk_widget_hide(grid_gstreamer);
gtk_widget_show(gridBox);
gtk_widget_show_all(grid_button);
gtk_widget_show(hgridBox);
gtk_widget_show(box);
gtk_widget_show(stack);
gtk_widget_show(stackSwitcher);
gtk_widget_show_all(bar);
//get the setup
return setup;
}
static void
toggle_transitions (GtkWidget *combo, gpointer data)
{
int id = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
gtk_stack_set_transition_type (GTK_STACK (stack), id);
}
