static void
prepare_dialog_layout (GstConnectionDialog *dialog,
OobsIface *iface)
{
if (OOBS_IS_IFACE_PPP (iface))
{
gtk_widget_hide (dialog->wireless_frame);
gtk_widget_hide (dialog->ethernet_frame);
gtk_widget_hide (dialog->plip_frame);
gtk_widget_show (dialog->options_page);
gtk_widget_show (dialog->isp_frame);
gtk_widget_show (dialog->account_frame);
gtk_widget_show (dialog->ppp_type_box);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (dialog->notebook), TRUE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (dialog->notebook), TRUE);
gtk_notebook_set_current_page (GTK_NOTEBOOK (dialog->notebook), 0);
gtk_container_set_border_width (GTK_CONTAINER (dialog->general_page), 12);
gtk_container_set_border_width (GTK_CONTAINER (dialog->notebook), 6);
gtk_widget_show (dialog->modem_page);
/* FIXME: hide/show things depending on PPP type */
}
else
{
gtk_widget_show (dialog->general_page);
gtk_widget_hide (dialog->modem_page);
gtk_widget_hide (dialog->options_page);
gtk_widget_hide (dialog->isp_frame);
gtk_widget_hide (dialog->account_frame);
gtk_widget_hide (dialog->ppp_type_box);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (dialog->notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (dialog->notebook), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (dialog->general_page), 0);
gtk_container_set_border_width (GTK_CONTAINER (dialog->notebook), 0);
if (OOBS_IS_IFACE_ETHERNET (iface))
{
gtk_widget_show (dialog->ethernet_frame);
gtk_widget_hide (dialog->plip_frame);
if (OOBS_IS_IFACE_WIRELESS (iface))
gtk_widget_show (dialog->wireless_frame);
else
gtk_widget_hide (dialog->wireless_frame);
}
else if (OOBS_IS_IFACE_PLIP (iface))
{
gtk_widget_hide (dialog->wireless_frame);
gtk_widget_hide (dialog->ethernet_frame);
gtk_widget_show (dialog->plip_frame);
}
}
}
static void
cedit_notebook_init (CeditNotebook *notebook)
{
notebook->priv = CEDIT_NOTEBOOK_GET_PRIVATE (notebook);
notebook->priv->close_buttons_sensitive = TRUE;
notebook->priv->tab_drag_and_drop_enabled = TRUE;
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
notebook->priv->always_show_tabs = TRUE;
g_signal_connect (notebook,
"button-press-event",
(GCallback)button_press_cb,
NULL);
g_signal_connect (notebook,
"button-release-event",
(GCallback)button_release_cb,
NULL);
gtk_widget_add_events (GTK_WIDGET (notebook),
GDK_BUTTON1_MOTION_MASK);
g_signal_connect_after (G_OBJECT (notebook),
"switch_page",
G_CALLBACK (cedit_notebook_switch_page_cb),
NULL);
}
/**
* uber_window_init:
* @window: A #UberWindow.
*
* Initializes the newly created #UberWindow instance.
*
* Returns: None.
* Side effects: None.
*/
static void
uber_window_init (UberWindow *window) /* IN */
{
UberWindowPrivate *priv;
window->priv = G_TYPE_INSTANCE_GET_PRIVATE(window,
UBER_TYPE_WINDOW,
UberWindowPrivate);
/*
* Initialize defaults.
*/
priv = window->priv;
gtk_window_set_title(GTK_WINDOW(window), "Uber Graph");
gtk_window_set_default_size(GTK_WINDOW(window), 750, 550);
gtk_container_set_border_width(GTK_CONTAINER(window), 12);
/*
* Create notebook container for pages.
*/
priv->notebook = gtk_notebook_new();
gtk_notebook_set_show_border(GTK_NOTEBOOK(priv->notebook), FALSE);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(priv->notebook), FALSE);
gtk_container_add(GTK_CONTAINER(window), priv->notebook);
gtk_widget_show(priv->notebook);
/*
* Create table for graphs.
*/
priv->table = gtk_grid_new();
gtk_grid_set_row_homogeneous(GTK_GRID(priv->table), TRUE);
gtk_grid_set_column_homogeneous(GTK_GRID(priv->table), TRUE);
gtk_notebook_append_page(GTK_NOTEBOOK(priv->notebook), priv->table, NULL);
gtk_widget_show(priv->table);
}
static GtkWidget *
notebook_new(GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *notebook = gtk_notebook_new();
GList *tmp;
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "popup_enable")) {
if (attr->value[0] == 'T')
gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
else
gtk_notebook_popup_disable(GTK_NOTEBOOK(notebook));
} else if (!strcmp(attr->name, "scrollable"))
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook),
attr->value[0] == 'T');
else if (!strcmp(attr->name, "show_border"))
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook),
attr->value[0] == 'T');
else if (!strcmp(attr->name, "show_tabs"))
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook),
attr->value[0] == 'T');
else if (!strcmp(attr->name, "tab_pos"))
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook),
glade_enum_from_string(GTK_TYPE_POSITION_TYPE,
attr->value));
}
return notebook;
}
widget_t *
widget_notebook(widget_t *w)
{
w->index = luaH_notebook_index;
w->newindex = luaH_notebook_newindex;
w->destructor = notebook_destructor;
/* create and setup notebook widget */
w->widget = gtk_notebook_new();
g_object_set_data(G_OBJECT(w->widget), "widget", (gpointer) w);
gtk_notebook_set_show_border(GTK_NOTEBOOK(w->widget), FALSE);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(w->widget), TRUE);
g_object_connect((GObject*)w->widget,
"signal::focus-in-event", (GCallback)focus_cb, w,
"signal::focus-out-event", (GCallback)focus_cb, w,
"signal::key-press-event", (GCallback)key_press_cb, w,
"signal::page-added", (GCallback)page_added_cb, w,
"signal::page-removed", (GCallback)page_removed_cb, w,
"signal::switch-page", (GCallback)switch_cb, w,
"signal::parent-set", (GCallback)parent_set_cb, w,
NULL);
gtk_widget_show(w->widget);
return w;
}
/* setup the main window */
static void new_window() {
window *w = g_new0(window, 1);
term_data_id = g_quark_from_static_string("svte");
w->notebook = gtk_notebook_new();
gtk_notebook_set_show_border(GTK_NOTEBOOK(w->notebook), FALSE);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(w->notebook), TRUE);
w->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
if (config->fullscreen) {
gtk_window_fullscreen(GTK_WINDOW(w->win));
}
gtk_window_set_default_size(GTK_WINDOW(w->win),
config->window_width,
config->window_height);
gtk_container_add(GTK_CONTAINER(w->win), w->notebook);
tab_new(w);
gtk_widget_show_all(w->win);
/* add the callback signals */
g_signal_connect(G_OBJECT(w->win), "key-press-event", G_CALLBACK(event_key), w);
g_signal_connect(G_OBJECT(w->notebook), "switch-page", G_CALLBACK(tab_focus), w);
g_signal_connect(G_OBJECT(w->win), "destroy", G_CALLBACK(window_destroy), w);
set_window_title(get_current_term(w));
}
void Notebook::create(Window *wnd,uint32_t st) {
if(style&NOTEBOOK_HIDE_TABS) {
style &= ~NOTEBOOK_CLOSE_BUTTON;
type = WIDGET_CONTAINER;
}
#ifdef USE_GTK
component = gtk_notebook_new();
if(style&NOTEBOOK_HIDE_TABS) {
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(component),FALSE);
} else {
gtk_notebook_set_show_border(GTK_NOTEBOOK(component),FALSE);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(component),TRUE);
gtk_notebook_set_tab_border(GTK_NOTEBOOK(component),3);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(component),GTK_POS_TOP);
g_signal_connect(G_OBJECT(component),"switch-page",G_CALLBACK(switch_page_event_callback),&selected);
}
#endif
debug_output("Notebook::create()\n");
Widget::create(wnd,0);
#ifdef USE_WIN32
captureEvents();
#endif
}
static void
caja_notebook_init (CajaNotebook *notebook)
{
#if GTK_CHECK_VERSION (3, 0, 0)
GtkStyleContext *context;
context = gtk_widget_get_style_context (GTK_WIDGET (notebook));
gtk_style_context_add_class (context, "caja-notebook");
#endif
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
g_signal_connect (notebook, "button-press-event",
(GCallback)button_press_cb, NULL);
/* Set up drag-and-drop target */
/* TODO this would be used for opening a new tab.
* It will only work properly as soon as GtkNotebook
* supports to find out whether a particular point
* is on a tab button or not.
*/
#if 0
gtk_drag_dest_set (GTK_WIDGET (notebook), 0,
url_drag_types, G_N_ELEMENTS (url_drag_types),
GDK_ACTION_LINK);
gtk_drag_dest_set_track_motion (GTK_WIDGET (notebook), TRUE);
#endif
}
void gui_job_dialog(void)
{
gpointer dialog;
GtkWidget *window, *notebook, *page, *label;
dialog = dialog_request(777, "Remote job manager", NULL, NULL, NULL);
if (!dialog)
return;
window = dialog_window(dialog);
gtk_widget_set_size_request(window, 400, 400);
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(window)->vbox), notebook);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
/* run type page */
page = gtk_vbox_new(FALSE, 0);
label = gtk_label_new(" Hosts ");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
gui_host_page(page, dialog);
/* run type page */
page = gtk_vbox_new(FALSE, 0);
label = gtk_label_new(" Jobs ");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
gui_job_page(page);
gtk_widget_show_all(window);
/* FIXME - active host */
if (sysenv.host_list)
gui_host_update(sysenv.host_list->data, dialog);
}
accxq_t *
accxq_new ()
{
accxq_t *xq;
xq = calloc (1, sizeof (accxq_t));
if (xq == NULL)
{
acc_err (_("Memory error\n"));
return NULL;
}
ecco_init ();
xq->widget = gtk_hbox_new (FALSE, 2);
xq->pantab = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (xq->pantab), TRUE);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (xq->pantab), TRUE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (xq->pantab), TRUE);
gtk_box_pack_start (GTK_BOX (xq->widget), xq->pantab, TRUE, TRUE, 2);
accxq_onload (xq);
if (g_xq == NULL)
{
g_xq = xq;
}
return xq;
}
void C4DevmodeDlg::AddPage(GtkWidget* widget, GtkWindow* parent, const char* title)
{
// Create Window if necessary
if (window == NULL)
{
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), false);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), false);
gtk_widget_show(GTK_WIDGET(notebook));
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_add(GTK_CONTAINER(window), notebook);
gtk_window_set_resizable(GTK_WINDOW(window), true);
gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_UTILITY);
gtk_window_set_default_size(GTK_WINDOW(window), 320, 320);
gtk_window_set_role(GTK_WINDOW(window), "toolbox");
gtk_window_set_transient_for(GTK_WINDOW(window), parent);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ON_PARENT);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(OnDeleteEvent), NULL);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(OnDestroy), NULL);
}
// Add page to notebook
GtkWidget* label = gtk_label_new(title);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), widget, label);
}
gu_tab_t *
gu_tab_create(gu_window_t *gw, int select, prop_t *nav)
{
gu_tab_t *gt = calloc(1, sizeof(gu_tab_t));
prop_sub_t *s;
int idx;
gt->gt_gw = gw;
LIST_INSERT_HEAD(&gw->gw_tabs, gt, gt_link);
gw->gw_current_tab = gt;
gw->gw_ntabs++;
gt->gt_nav = nav ?: nav_spawn();
if(prop_set_parent(gt->gt_nav, prop_get_global()))
abort();
gt->gt_vbox = gtk_vbox_new(FALSE, 1);
gtk_widget_show(gt->gt_vbox);
gt->gt_notebook = gtk_notebook_new();
gtk_widget_show(gt->gt_notebook);
gtk_notebook_set_show_border(GTK_NOTEBOOK(gt->gt_notebook), 0);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gt->gt_notebook), 0);
gu_toolbar_add(gt, gt->gt_vbox);
gtk_container_add(GTK_CONTAINER(gt->gt_vbox), gt->gt_notebook);
build_tab_header(gt);
s = prop_subscribe(0,
PROP_TAG_NAME("nav", "pages"),
PROP_TAG_CALLBACK, gu_nav_pages, gt,
PROP_TAG_COURIER, glibcourier,
PROP_TAG_NAMED_ROOT, gt->gt_nav, "nav",
NULL);
gu_unsubscribe_on_destroy(GTK_OBJECT(gt->gt_notebook), s);
// Add to tab's notebook
idx = gtk_notebook_append_page(GTK_NOTEBOOK(gw->gw_notebook),
gt->gt_vbox, gt->gt_label);
gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(gw->gw_notebook),
gt->gt_vbox, 1);
if(select)
gtk_notebook_set_current_page(GTK_NOTEBOOK(gw->gw_notebook), idx);
if(gw->gw_ntabs > 1)
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gw->gw_notebook), 1);
return gt;
}
void pTabFrame::constructor() {
gtkWidget = gtk_notebook_new();
gtk_notebook_set_show_border(GTK_NOTEBOOK(gtkWidget), false);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(gtkWidget), GTK_POS_TOP);
g_signal_connect(G_OBJECT(gtkWidget), "switch-page", G_CALLBACK(TabFrame_change), (gpointer)&tabFrame);
setSelection(tabFrame.state.selection);
}
static void
gnm_notebook_init (GnmNotebook *notebook)
{
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), "Gnumeric");
}
static GtkWidget *archs_stats_page (void) {
GtkWidget *page_vbox;
GtkWidget *alignment;
GtkWidget *option_menu;
GtkWidget *hbox;
int pagenum = 0;
enum server_type type = Q2_SERVER;
enum server_type to_activate = UNKNOWN_SERVER;
page_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (page_vbox), 8);
alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
arch_notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (arch_notebook), FALSE);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (arch_notebook), GTK_POS_TOP);
gtk_notebook_set_tab_hborder (GTK_NOTEBOOK (arch_notebook), 4);
gtk_notebook_set_show_border(GTK_NOTEBOOK(arch_notebook), FALSE);
gtk_container_add (GTK_CONTAINER (alignment), arch_notebook);
to_activate = config_get_int("/" CONFIG_FILE "/Statistics/game");
for (type = 0; type < GAMES_TOTAL; ++type) {
if (!create_server_type_menu_filter_hasharch(type))
continue;
srv_archs[type].notebookpage=pagenum++;
arch_notebook_page (arch_notebook, type, &srv_archs[type]);
}
// the notebook must exist to allow activate events of the menu
hbox = gtk_hbox_new(FALSE,0);
gtk_box_pack_start (GTK_BOX (page_vbox), hbox, FALSE, TRUE, 0);
option_menu = create_server_type_menu (to_activate,
create_server_type_menu_filter_hasharch,
GTK_SIGNAL_FUNC(select_server_type_callback));
gtk_box_pack_start (GTK_BOX (hbox), option_menu, TRUE, FALSE, 0);
gtk_widget_show (option_menu);
gtk_widget_show(hbox);
gtk_box_pack_start (GTK_BOX (page_vbox), alignment, TRUE, TRUE, 0);
gtk_widget_show (arch_notebook);
gtk_widget_show (alignment);
gtk_widget_show (page_vbox);
return page_vbox;
}
static void
cheese_widget_init (CheeseWidget *widget)
{
CheeseWidgetPrivate *priv = CHEESE_WIDGET_GET_PRIVATE (widget);
GtkWidget *box;
ClutterActor *stage, *frame;
ClutterConstraint *constraint;
ClutterColor black = { 0x00, 0x00, 0x00, 0xff };
priv->state = CHEESE_WIDGET_STATE_NONE;
priv->error = NULL;
/* XXX
* remove this line if you want to debug */
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (widget), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (widget), FALSE);
/* Spinner page */
priv->spinner = gtk_spinner_new ();
box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), priv->spinner);
cheese_widget_spinner_invert (priv->spinner, box);
gtk_widget_show_all (box);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
box, gtk_label_new ("spinner"));
/* Webcam page */
priv->screen = gtk_clutter_embed_new ();
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (priv->screen));
clutter_stage_set_color (CLUTTER_STAGE (stage), &black);
frame = cheese_aspect_frame_new ();
priv->texture = clutter_texture_new ();
clutter_actor_set_size (priv->texture, 400, 300);
mx_bin_set_child (MX_BIN (frame), priv->texture);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), frame);
constraint = clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0.0);
clutter_actor_add_constraint_with_name (frame, "size", constraint);
gtk_widget_show (priv->screen);
clutter_actor_show (priv->texture);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
priv->screen, gtk_label_new ("webcam"));
/* Problem page */
priv->problem = gtk_drawing_area_new ();
gtk_widget_show (priv->problem);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
priv->problem,
gtk_label_new ("got problems"));
priv->settings = g_settings_new ("org.gnome.Cheese");
}
/* Add/Remove the page tabs and the borders */
void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
{
gint tval = FALSE;
gint bval = FALSE;
if (notebook->show_tabs == 0)
tval = TRUE;
if (notebook->show_border == 0)
bval = TRUE;
gtk_notebook_set_show_tabs (notebook, tval);
gtk_notebook_set_show_border (notebook, bval);
}
/* Sets whether to show the border of the notebook or not.
* Bookmarks are in the border. */
int
clip_GTK_NOTEBOOKSETSHOWBORDER(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
gboolean show_border = _clip_parl(cm,2);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,LOGICAL_t);
if (_clip_parinfo(cm,2)==UNDEF_t) show_border = TRUE;
gtk_notebook_set_show_border(GTK_NOTEBOOK(cntb->widget), show_border);
return 0;
err:
return 1;
}
static void
cheese_avatar_widget_init (CheeseAvatarWidget *widget)
{
CheeseAvatarWidgetPrivate *priv;
GtkWidget *frame;
GtkWidget *image;
priv = cheese_avatar_widget_get_instance_private (widget);
priv->flash = cheese_flash_new (GTK_WIDGET (widget));
priv->notebook = gtk_notebook_new ();
g_object_set(G_OBJECT (priv->notebook), "margin", 12, NULL);
gtk_notebook_set_show_border (GTK_NOTEBOOK (priv->notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (priv->notebook), FALSE);
gtk_container_add (GTK_CONTAINER (widget), priv->notebook);
/* Camera tab */
priv->camera = cheese_widget_new ();
g_signal_connect (G_OBJECT (priv->camera), "notify::state",
G_CALLBACK (state_change_cb), widget);
image = gtk_image_new_from_icon_name ("camera-photo-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
priv->take_button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (priv->take_button), image);
g_signal_connect (G_OBJECT (priv->take_button), "clicked",
G_CALLBACK (take_button_clicked_cb), widget);
gtk_widget_set_sensitive (priv->take_button, FALSE);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
create_page (priv->camera, priv->take_button),
gtk_label_new ("webcam"));
/* Image tab */
priv->image = um_crop_area_new ();
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (frame), priv->image);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
priv->take_again_button = gtk_button_new_with_mnemonic (_("_Take Another Picture"));
g_signal_connect (G_OBJECT (priv->take_again_button), "clicked",
G_CALLBACK (take_again_button_clicked_cb), widget);
gtk_widget_set_sensitive (priv->take_again_button, FALSE);
gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
create_page (frame, priv->take_again_button),
gtk_label_new ("image"));
priv->sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget (priv->sizegroup, priv->take_button);
gtk_size_group_add_widget (priv->sizegroup, priv->take_again_button);
gtk_widget_show_all (GTK_WIDGET (widget));
}
void
shell_init(void)
{
if (shell) {
g_error("Shell already created");
return;
}
create_window();
shell->tree = tree_new();
shell->info = info_tree_new(FALSE);
shell->moreinfo = info_tree_new(TRUE);
shell->loadgraph = load_graph_new(75);
gtk_paned_pack1(GTK_PANED(shell->hpaned), shell->tree->scroll,
SHELL_PACK_RESIZE, SHELL_PACK_SHRINK);
gtk_paned_pack1(GTK_PANED(shell->vpaned), shell->info->scroll,
SHELL_PACK_RESIZE, SHELL_PACK_SHRINK);
gtk_notebook_append_page(GTK_NOTEBOOK(shell->notebook),
shell->moreinfo->scroll, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(shell->notebook),
load_graph_get_framed(shell->loadgraph), NULL);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(shell->notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(shell->notebook), FALSE);
shell_status_set_enabled(TRUE);
shell_status_update("Loading modules...");
shell_tree_modules_load(shell->tree);
g_slist_foreach(shell->tree->modules, add_modules_to_gui, shell->tree);
gtk_tree_view_expand_all(GTK_TREE_VIEW(shell->tree->view));
shell_status_update("Done.");
shell_status_set_enabled(FALSE);
gtk_widget_show_all(shell->hpaned);
load_graph_configure_expose(shell->loadgraph);
gtk_widget_hide(shell->notebook);
shell_action_set_enabled("RefreshAction", FALSE);
shell_action_set_active("LeftPaneAction", TRUE);
shell_action_set_active("ToolbarAction", TRUE);
shell_action_set_property("RefreshAction", "is-important", TRUE);
shell_action_set_property("ReportAction", "is-important", TRUE);
}
static void
anjuta_command_bar_init (AnjutaCommandBar *self)
{
self->priv = g_new0 (AnjutaCommandBarPriv, 1);
gtk_notebook_set_show_border (GTK_NOTEBOOK (self), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self), FALSE);
/* The action groups table contains the GtkActionGroup objects that
* correspond to each page of the action bar. The widgets table contain's
* each group's set of buttons and frames. */
self->priv->action_groups = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, g_object_unref);
self->priv->widgets = g_hash_table_new (g_str_hash, g_str_equal);
}
int main (int argc, char **argv)
{
GtkWidget *window, *notebook;
GList *devices;
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
if (gtk_clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) {
g_critical ("Unable to initialize Clutter");
return 1;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_default_size (GTK_WINDOW (window), FIXED_WIDTH, -1);
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (delete_event_cb), NULL);
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
gtk_widget_set_vexpand (notebook, TRUE);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 24);
gtk_container_add (GTK_CONTAINER (window), notebook);
gtk_widget_show (notebook);
devices = create_fake_intuos4 ();
add_page (devices, notebook);
devices = create_fake_cintiq ();
add_page (devices, notebook);
devices = create_fake_bt ();
add_page (devices, notebook);
devices = create_fake_x201 ();
add_page (devices, notebook);
devices = create_fake_h610pro ();
add_page (devices, notebook);
gtk_widget_show (window);
gtk_main ();
return 0;
}
static void
gedit_notebook_init (GeditNotebook *notebook)
{
GeditNotebookPrivate *priv;
notebook->priv = gedit_notebook_get_instance_private (notebook);
priv = notebook->priv;
priv->close_buttons_sensitive = TRUE;
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), TRUE);
gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook),
GEDIT_NOTEBOOK_GROUP_NAME);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 0);
}
static void
cc_mouse_panel_init (CcMousePanel *self)
{
CcMousePanelPrivate *priv;
GtkBuilder *dialog;
GError *error = NULL;
priv = self->priv = MOUSE_PANEL_PRIVATE (self);
priv->builder = gtk_builder_new ();
gtk_builder_add_from_file (priv->builder,
CINNAMONCC_UI_DIR "/cinnamon-mouse-properties.ui",
&error);
if (error != NULL)
{
g_warning ("Error loading UI file: %s", error->message);
return;
}
gtk_builder_add_from_file (priv->builder,
CINNAMONCC_UI_DIR "/cinnamon-mouse-test.ui",
&error);
if (error != NULL)
{
g_warning ("Error loading UI file: %s", error->message);
return;
}
dialog = priv->builder;
priv->prefs_widget = gnome_mouse_properties_init (priv->builder);
priv->test_widget = gnome_mouse_test_init (priv->builder);
priv->widget = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (priv->widget), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (priv->widget), FALSE);
gtk_widget_reparent (WID ("prefs_widget"), priv->widget);
gtk_widget_reparent (WID ("test_widget"), priv->widget);
gtk_container_add (GTK_CONTAINER (self), priv->widget);
gtk_widget_show (priv->widget);
g_idle_add (add_shell_test_button_cb, self);
}
static GtkWidget *
mk_dialog()
{
GtkWidget *sw, *nb, *label;
DBG("creating dialog\n");
dialog = gtk_dialog_new_with_buttons ("fbpanel configurator",
NULL,
0, //GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_APPLY,
GTK_RESPONSE_APPLY,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
DBG("connecting sugnal to %p\n", dialog);
g_signal_connect (G_OBJECT(dialog), "response", (GCallback) response_event, NULL);
g_signal_connect (G_OBJECT(dialog), "destroy", (GCallback) dialog_destroy_event, NULL);
g_signal_connect (G_OBJECT(dialog), "delete_event", (GCallback) dialog_delete_event, NULL);
gtk_window_set_modal(GTK_WINDOW(dialog), FALSE);
gtk_window_set_default_size(GTK_WINDOW(dialog), 400, 500);
//gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), TRUE);
//gtk_window_set_skip_pager_hint(GTK_WINDOW(dialog), TRUE);
nb = gtk_notebook_new();
gtk_notebook_set_show_border (GTK_NOTEBOOK(nb), FALSE);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), nb);
sw = mk_tab_general();
label = gtk_label_new("General");
gtk_misc_set_padding(GTK_MISC(label), 4, 1);
gtk_notebook_append_page(GTK_NOTEBOOK(nb), sw, label);
sw = mk_tab_plugins();
label = gtk_label_new("Plugins");
gtk_misc_set_padding(GTK_MISC(label), 4, 1);
gtk_notebook_append_page(GTK_NOTEBOOK(nb), sw, label);
g_object_unref(sg);
//gtk_widget_show_all(page);
gtk_widget_show_all(dialog);
RET(dialog);
}
//____________________________________________________________________________________________
gboolean Animations::realizationHook( GSignalInvocationHint*, guint, const GValue* params, gpointer data )
{
// get widget from params
GtkWidget* widget( GTK_WIDGET( g_value_get_object( params ) ) );
// check type
if( !GTK_IS_WIDGET( widget ) ) return FALSE;
if( GTK_IS_NOTEBOOK( widget ) )
{ gtk_notebook_set_show_border( GTK_NOTEBOOK(widget), FALSE ); }
#if ENABLE_GROUPBOX_HACK
if( GTK_IS_LABEL( widget ) && GTK_IS_FRAME( gtk_widget_get_parent( widget ) ) )
{
GtkFrame *frame( GTK_FRAME( gtk_widget_get_parent( widget ) ) );
if( widget == gtk_frame_get_label_widget( frame ) && !Gtk::gtk_widget_find_parent( widget, "GtkPizza" ) )
{
#if OXYGEN_DEBUG
std::cout
<< "Oxygen::Animations::realizationHook -"
<< " widget: " << widget << " (" << G_OBJECT_TYPE_NAME( widget ) << ")"
<< " parent: " << frame << " (" << G_OBJECT_TYPE_NAME( frame ) << ")"
<< std::endl;
#endif
// modify alignment
gtk_frame_set_label_align( frame, 0.5, 0.0 );
gtk_frame_set_shadow_type( frame, GTK_SHADOW_OUT );
// register to engine
Animations& animations( *static_cast<Animations*>(data) );
animations.groupBoxLabelEngine().registerWidget( widget );
animations.groupBoxLabelEngine().adjustSize( widget );
}
}
#endif
return TRUE;
}
static void qq_mainwindow_init(QQMainWindow *win)
{
GtkWidget *w = GTK_WIDGET(win);
gtk_widget_set_size_request(w, 200, 500);
gtk_window_resize(GTK_WINDOW(w), 250, 550);
// gtk_window_set_resizable(GTK_WINDOW(w), FALSE);
g_signal_connect(w, "delete-event",
G_CALLBACK(qq_mainwindow_close), NULL);
win -> login_panel = qq_loginpanel_new(w);
win -> splash_panel = qq_splashpanel_new();
win -> main_panel = qq_mainpanel_new(w);
win -> showed = FALSE;
win -> notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(win -> notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(win -> notebook), FALSE);
gtk_widget_show_all(win -> login_panel);
gtk_widget_show_all(win -> splash_panel);
gtk_widget_show_all(win -> main_panel);
gtk_notebook_append_page(GTK_NOTEBOOK(win -> notebook)
, win -> login_panel, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(win -> notebook)
, win -> splash_panel, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(win -> notebook)
, win -> main_panel, NULL);
gtk_container_add(GTK_CONTAINER(win), win -> notebook);
GdkPixbuf *pb = gdk_pixbuf_new_from_file(IMGDIR"webqq_icon.png", NULL);
gtk_window_set_icon(GTK_WINDOW(win), pb);
g_object_unref(pb);
gtk_window_set_title(GTK_WINDOW(win), "GtkQQ");
/*
* Test
*/
// gtk_notebook_set_current_page(GTK_NOTEBOOK(win -> notebook), 2);
// qq_mainpanel_update(QQ_MAINPANEL(win -> main_panel));
}
static GtkWidget *build_develop_panel(void)
{
develop_notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(develop_notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(develop_notebook),
FALSE);
gtk_widget_show(develop_notebook);
gtk_notebook_insert_page(GTK_NOTEBOOK(develop_notebook),
develop_build_page(), NULL, 0);
gtk_notebook_insert_page(GTK_NOTEBOOK(develop_notebook),
discard_build_page(), NULL, 1);
gtk_notebook_insert_page(GTK_NOTEBOOK(develop_notebook),
gold_build_page(), NULL, 2);
gtk_notebook_insert_page(GTK_NOTEBOOK(develop_notebook),
prompt_build_page(), NULL, 3);
return develop_notebook;
}
GtkWidget *
gtk_utils_create_invisible_notebook (void)
{
GtkWidget *notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
g_signal_connect (notebook, "key-press-event",
G_CALLBACK (block_key_signal),
GINT_TO_POINTER (g_signal_lookup ("key-press-event",
GTK_TYPE_WIDGET)));
g_signal_connect (notebook, "key-release-event",
G_CALLBACK (block_key_signal),
GINT_TO_POINTER (g_signal_lookup ("key-release-event",
GTK_TYPE_WIDGET)));
return notebook;
}
static GtkWidget *
pdg_demo_notebook_create (PopplerDocument *document)
{
GtkWidget *notebook;
gint i;
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
for (i = 0; i < G_N_ELEMENTS (demo_list); i++) {
GtkWidget *demo_widget;
demo_widget = demo_list[i].create_widget (document);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), demo_widget, NULL);
gtk_widget_show (demo_widget);
}
return notebook;
}
