/* special things for the initial setup of the checkboxes and related stuff
* an action on a setting is only performed if the setting is not equal to the program default
* (all the following code is not perfect but it works for the moment) */
static void apply_settings(void)
{
ui_update_fold_items();
/* toolbar, message window and sidebar are by default visible, so don't change it if it is true */
toolbar_show_hide();
if (! ui_prefs.msgwindow_visible)
{
ignore_callback = TRUE;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_show_messages_window1")), FALSE);
gtk_widget_hide(ui_lookup_widget(main_widgets.window, "scrolledwindow1"));
ignore_callback = FALSE;
}
if (! ui_prefs.sidebar_visible)
{
ignore_callback = TRUE;
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_show_sidebar1")), FALSE);
ignore_callback = FALSE;
}
toolbar_apply_settings();
toolbar_update_ui();
ui_update_view_editor_menu_items();
/* hide statusbar if desired */
if (! interface_prefs.statusbar_visible)
{
gtk_widget_hide(ui_widgets.statusbar);
}
/* set the tab placements of the notebooks */
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_widgets.notebook), interface_prefs.tab_pos_editor);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(msgwindow.notebook), interface_prefs.tab_pos_msgwin);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_widgets.sidebar_notebook), interface_prefs.tab_pos_sidebar);
/* whether to show notebook tabs or not */
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(main_widgets.notebook), interface_prefs.show_notebook_tabs);
#ifdef HAVE_VTE
if (! vte_info.have_vte)
#endif
{
gtk_widget_set_sensitive(
ui_lookup_widget(main_widgets.window, "send_selection_to_vte1"), FALSE);
}
if (interface_prefs.sidebar_pos != GTK_POS_LEFT)
ui_swap_sidebar_pos();
gtk_orientable_set_orientation(GTK_ORIENTABLE(ui_lookup_widget(main_widgets.window, "vpaned1")),
interface_prefs.msgwin_orientation);
}
bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
m_needParent = true;
m_acceptsFocus = true;
m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook;
if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
style |= wxBK_TOP;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxNoteBook creation failed") );
return false;
}
m_widget = gtk_notebook_new();
gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
g_signal_connect (m_widget, "switch_page",
G_CALLBACK (gtk_notebook_page_changing_callback), this);
g_signal_connect_after (m_widget, "switch_page",
G_CALLBACK (gtk_notebook_page_changed_callback), this);
m_parent->DoAddChild( this );
if (m_windowStyle & wxBK_RIGHT)
gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT );
if (m_windowStyle & wxBK_LEFT)
gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT );
if (m_windowStyle & wxBK_BOTTOM)
gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM );
g_signal_connect (m_widget, "key_press_event",
G_CALLBACK (gtk_notebook_key_press_callback), this);
PostCreation(size);
g_signal_connect (m_widget, "realize",
G_CALLBACK (gtk_notebook_realized_callback), this);
return true;
}
static void
gam_app_init (GamApp *gam_app)
{
GamAppPrivate *priv;
g_return_if_fail (GAM_IS_APP (gam_app));
priv = GAM_APP_GET_PRIVATE (gam_app);
priv->gconf_client = gconf_client_get_default ();
/*gconf_client_add_dir (priv->gconf_client,
"/apps/PAW/PAWed/preferences",
GCONF_CLIENT_PRELOAD_NONE,
NULL);*/
priv->ui_manager = gtk_ui_manager_new ();
priv->ui_accel_group = gtk_ui_manager_get_accel_group (priv->ui_manager);
priv->main_action_group = gtk_action_group_new ("MainActions");
#ifdef ENABLE_NLS
gtk_action_group_set_translation_domain (priv->main_action_group, GETTEXT_PACKAGE);
#endif
priv->status_bar = gtk_statusbar_new ();
priv->tip_message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (priv->status_bar),
"GamAppToolTips");
priv->notebook = gtk_notebook_new ();
gtk_notebook_set_scrollable (GTK_NOTEBOOK (priv->notebook), TRUE);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (priv->notebook), GTK_POS_TOP);
priv->view_mixers_cb_active=TRUE;
}
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);
}
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;
}
void GroupDlg::Create(GtkWindow* parent)
{
ASSERT_MESSAGE(m_window == 0, "dialog already created");
GtkWindow* window = create_persistent_floating_window("Entities", parent);
global_accel_connect_window(window);
window_connect_focus_in_clear_focus_widget(window);
m_window = window;
#ifdef WIN32
if( g_multimon_globals.m_bStartOnPrimMon )
{
WindowPosition pos(m_position_tracker.getPosition());
PositionWindowOnPrimaryScreen(pos);
m_position_tracker.setPosition(pos);
}
#endif
m_position_tracker.connect(window);
{
GtkWidget* notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_container_add (GTK_CONTAINER (window), notebook);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM);
m_pNotebook = notebook;
g_signal_connect(G_OBJECT(notebook), "switch_page", G_CALLBACK(switch_page), window);
}
}
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
}
int main( int argc , char **argv )
{
GtkWidget *window;
GtkWidget *note;
/* GtkWidget *button;*/
gtk_init( &argc , &argv );
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_signal_connect( GTK_OBJECT(window) , "delete_event" ,
GTK_SIGNAL_FUNC( delete_event ), NULL );
note = gtk_notebook_new();
gtk_notebook_set_tab_pos( GTK_NOTEBOOK(note), GTK_POS_TOP );
gtk_container_add( GTK_CONTAINER(window) , note );
gtk_widget_show( note );
gtk_widget_show( window );
gtk_main();
return 0;
}
int main (int argc,char *argv[])
{
GtkWidget *window, *notebook;
GtkWidget *label1, *label2, *child1, *child2;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Notebook");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (window, 250, 100);
notebook= gtk_notebook_new ();
label1 =gtk_label_new ("Page One");
label2 =gtk_label_new ("Page Two");
child1 =gtk_label_new ("Go to page 2 to find the answer.");
child2 =gtk_label_new ("Go to page 1 to find the answer.");
/* Notice that two widgets were connected to the same callback function! */
g_signal_connect (G_OBJECT (child1), "clicked",G_CALLBACK (switch_page),(gpointer) notebook);
g_signal_connect (G_OBJECT (child2), "clicked",G_CALLBACK (switch_page),(gpointer) notebook);
/* Append to pages to the notebook container. */
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), child1, label1);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), child2, label2);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM);
gtk_container_add (GTK_CONTAINER (window), notebook);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
GtkWidget *
notebook_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
GSList *tab;
/* get shared memory */
tabs = get_tabs (options.common_data.key, TRUE);
if (!tabs)
exit (-1);
/* create widget */
w = notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (w), options.notebook_data.pos);
gtk_container_set_border_width (GTK_CONTAINER (w), 5);
/* add tabs */
for (tab = options.notebook_data.tabs; tab; tab = tab->next)
{
GtkWidget *a, *s;
a = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (a),
options.notebook_data.borders, options.notebook_data.borders,
options.notebook_data.borders, options.notebook_data.borders);
s = gtk_socket_new ();
gtk_container_add (GTK_CONTAINER (a), s);
g_object_set_data (G_OBJECT (a), "socket", s);
gtk_notebook_append_page (GTK_NOTEBOOK (w), a, get_label ((gchar *) tab->data, 0));
}
return w;
}
void InitScreen(void)
{
GtkWidget *notebook;
GtkWidget *playbacklabel;
GtkWidget *capturelabel;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), "Lightweight Alsa Mixer");
//gtk_container_set_border_width (GTK_CONTAINER (window), 1);
gtk_signal_connect (GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
windowbox = gtk_vbox_new(FALSE,1);
InitMenu();
gtk_box_pack_start(GTK_BOX(windowbox), menu_bar, FALSE, TRUE, 0);
lamixer_enum_cards();
lamixer_mixer_init(card_id);
mixerbox = gtk_table_new(mRows, 1, FALSE);
capturebox = gtk_table_new(mRows, 1, FALSE);
InitMixer(card_id);
playbackscrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (playbackscrollwin),GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (playbackscrollwin), mixerbox);
capturescrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (capturescrollwin),GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (capturescrollwin), capturebox);
playbacklabel = gtk_label_new("Playback");
capturelabel = gtk_label_new("Capture");
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), playbackscrollwin, playbacklabel);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), capturescrollwin, capturelabel);
switchmixer = gtk_combo_box_new_text();
GList *card_name = g_list_first(SoundCards);
while(card_name) {
gtk_combo_box_append_text (GTK_COMBO_BOX (switchmixer), card_name->data);
card_name = g_list_next(card_name);
}
gtk_combo_box_set_active(GTK_COMBO_BOX (switchmixer), 0);
g_signal_connect(G_OBJECT(switchmixer), "changed", G_CALLBACK(lamixer_mixer_switch), NULL);
gtk_notebook_set_action_widget (GTK_NOTEBOOK (notebook), switchmixer, GTK_PACK_END);
gtk_widget_show(switchmixer);
gtk_box_pack_start(GTK_BOX(windowbox), notebook, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER(window), windowbox);
lamixer_window_resize();
gtk_widget_show_all (window);
}
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");
}
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 _tab_pos(GtkRadioAction *action,
GtkRadioAction *extra,
GtkNotebook *notebook)
{
working_sview_config.tab_pos =
gtk_radio_action_get_current_value(action);
gtk_notebook_set_tab_pos(notebook, working_sview_config.tab_pos);
}
mmio_window_t mmio_window_new( const gchar *title )
{
mmio_window_t mmio = g_malloc0( sizeof(struct mmio_window_info) );
int i, j;
GtkCList *all_list;
GtkWidget *vbox1;
GtkWidget *hbuttonbox1;
GtkWidget *mmr_close;
mmio->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (mmio->window), title);
gtk_window_set_default_size (GTK_WINDOW (mmio->window), 600, 600);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (mmio->window), vbox1);
mmio->notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox1), mmio->notebook, TRUE, TRUE, 0);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (mmio->notebook), GTK_POS_LEFT);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, TRUE, 0);
gtk_box_set_spacing (GTK_BOX (hbuttonbox1), 30);
mmr_close = gtk_button_new_with_mnemonic (_("Close"));
gtk_container_add (GTK_CONTAINER (hbuttonbox1), mmr_close);
GTK_WIDGET_SET_FLAGS (mmr_close, GTK_CAN_DEFAULT);
/* Add the mmio register data */
all_list = mmio_window_add_page( mmio, "All", NULL );
for( i=0; i < num_io_rgns; i++ ) {
GtkCList *list = mmio_window_add_page( mmio, io_rgn[i]->id, io_rgn[i] );
for( j=0; io_rgn[i]->ports[j].id != NULL; j++ ) {
int sz = io_rgn[i]->ports[j].width;
char addr[10], data[10], bits[40];
char *arr[] = { addr, io_rgn[i]->ports[j].id, data, bits,
io_rgn[i]->ports[j].desc };
sprintf( addr, "%08X",
io_rgn[i]->base + io_rgn[i]->ports[j].offset );
printhex( data, sz, *io_rgn[i]->ports[j].val );
printbits( bits, io_rgn[i]->ports[j].width,
*io_rgn[i]->ports[j].val );
gtk_clist_append( list, arr );
gtk_clist_append( all_list, arr );
}
}
g_signal_connect ((gpointer) mmio->window, "delete_event",
G_CALLBACK (on_mmio_delete_event),
NULL);
g_signal_connect ((gpointer) mmr_close, "clicked",
G_CALLBACK (on_mmio_close_clicked),
mmio);
gtk_widget_show_all( mmio->window );
return mmio;
}
int main(int argc, char *argv[])
{
GtkWidget *button;
GtkWidget *notebook;
GtkWidget *vbox;
GtkWidget *bbox;
gtk_init(&argc, &argv);
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), PACKAGE_NAME);
g_signal_connect(main_window, "delete_event", G_CALLBACK(quit_gtuxnes), NULL);
gtk_container_set_border_width(GTK_CONTAINER(main_window), PAD_BORDER);
vbox = gtk_vbox_new(FALSE, PAD_BORDER);
/* Create the 'notebook' and add the pages to it */
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
gtk_box_pack_start(GTK_BOX(vbox), notebook, FALSE, FALSE, 0);
add_page(notebook, create_general_options_page(), "General");
add_page(notebook, create_sound_options_page(), "Sound");
add_page(notebook, create_video_options_page(), "Video");
add_page(notebook, create_palette_options_page(), "Palette");
add_page(notebook, create_input_options_page(), "Input");
add_page(notebook, create_debug_options_page(), "Debug");
/* Create the Run and Quit buttons */
bbox = gtk_hbutton_box_new();
gtk_box_set_spacing(GTK_BOX(bbox), PAD_BORDER);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
button = gtk_button_new_from_stock(GTK_STOCK_EXECUTE);
g_signal_connect(button, "clicked", G_CALLBACK(run_tuxnes), NULL);
gtk_container_add(GTK_CONTAINER(bbox), button);
button = gtk_button_new_from_stock(GTK_STOCK_QUIT);
g_signal_connect(button, "clicked", G_CALLBACK(quit_gtuxnes), NULL);
gtk_container_add(GTK_CONTAINER(bbox), button);
gtk_box_pack_start(GTK_BOX(vbox), bbox, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(main_window), vbox);
gtk_widget_show_all(main_window);
config_file_name = g_build_filename(g_get_home_dir(), CONFIG_FILE_BASENAME, NULL);
read_config_file(config_file_name);
gtk_main();
g_free(config_file_name);
return(0);
}
bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
style |= wxBK_TOP;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxNoteBook creation failed") );
return false;
}
m_widget = gtk_notebook_new();
g_object_ref(m_widget);
gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
g_signal_connect (m_widget, "switch_page",
G_CALLBACK(switch_page), this);
g_signal_connect_after (m_widget, "switch_page",
G_CALLBACK(switch_page_after), this);
g_signal_handlers_block_by_func(m_widget, (void*)switch_page_after, this);
g_signal_connect(m_widget, "event_after", G_CALLBACK(event_after), this);
g_signal_handlers_block_by_func(m_widget, (void*)event_after, this);
m_parent->DoAddChild( this );
if (m_windowStyle & wxBK_RIGHT)
gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT );
if (m_windowStyle & wxBK_LEFT)
gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT );
if (m_windowStyle & wxBK_BOTTOM)
gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM );
PostCreation(size);
return true;
}
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;
}
/* Sets the position of the bookmarks. */
int
clip_GTK_NOTEBOOKSETTABPOS(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
GtkPositionType pos = _clip_parni(cm,2);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
CHECKOPT(2,NUMERIC_t);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(cntb->widget), pos);
return 0;
err:
return 1;
}
static void
create_sheets(GtkWidget *parent)
{
GtkWidget *notebook;
GtkWidget *separator;
GSList *list;
Sheet *sheet;
GtkWidget *child;
GtkWidget *label;
GtkWidget *menu_label;
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (parent), separator, FALSE, TRUE, 3);
gtk_widget_show(separator);
notebook = gtk_notebook_new ();
/*
gtk_signal_connect (GTK_OBJECT (notebook), "switch_page",
GTK_SIGNAL_FUNC (page_switch), NULL);
*/
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), TRUE);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_notebook_popup_enable (GTK_NOTEBOOK (notebook));
gtk_container_set_border_width (GTK_CONTAINER (notebook), 1);
gtk_box_pack_start (GTK_BOX (parent), notebook, TRUE, TRUE, 0);
list = get_sheets_list();
while (list != NULL) {
sheet = (Sheet *) list->data;
label = gtk_label_new(gettext(sheet->name));
menu_label = gtk_label_new(gettext(sheet->name));
gtk_misc_set_alignment(GTK_MISC(menu_label), 0.0, 0.5);
child = create_sheet_page(notebook, sheet);
gtk_widget_show(label);
gtk_widget_show(menu_label);
gtk_widget_show_all(child);
gtk_notebook_append_page_menu (GTK_NOTEBOOK (notebook),
child, label, menu_label);
list = g_slist_next(list);
}
gtk_widget_show(notebook);
}
void configure_panel(void)
{
gboolean short_tab_names = pref_panel_tab_pos == GTK_POS_LEFT ||
pref_panel_tab_pos == GTK_POS_RIGHT ||
geany_data->interface_prefs->msgwin_orientation == GTK_ORIENTATION_HORIZONTAL;
gtk_label_set_label(GTK_LABEL(get_widget("program_terminal_label")),
short_tab_names ? _("Program") : _("Program Terminal"));
gtk_label_set_label(GTK_LABEL(get_widget("break_view_label")),
short_tab_names ? _("Breaks") : _("Breakpoints"));
gtk_label_set_label(GTK_LABEL(get_widget("debug_console_label")),
short_tab_names ? _("Console") : _("Debug Console"));
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(debug_panel), pref_panel_tab_pos);
}
void *SONGDBUI_CreateWindow(void *ts)
{
SongdbWidgets *sw;
sw=malloc(sizeof(SongdbWidgets));
/* Create the notebook/tab section below the table*/
sw->Tabs=gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (sw->Tabs), GTK_POS_BOTTOM);
gtk_fixed_put(GTK_FIXED(ts),sw->Tabs,30,270);
gtk_widget_set_usize(sw->Tabs,500,310);
gtk_widget_show (sw->Tabs);
#if 0
SDL_SignalConnect(sw->Tabs,"switch-tab",SONGDB_ChangeDatabase,sw->Tabs);
#endif
#if 0
/* Create buttons which change the tabs */
while(Button)
{
switch(Button->action)
{
SDL_Widget *w;
case BUTTON_CHANGE_DIR:
#endif
{
GtkWidget *w;
w=gtk_button_new_with_label("Edit Group");
gtk_fixed_put(GTK_FIXED(ts),w,50,610);
gtk_widget_show(w);
}
#if 0
w=SDL_WidgetCreateR(SDL_BUTTON,Button->Rect);
SDL_WidgetPropertiesOf(w,SET_NORMAL_IMAGE,IMG_Load(Button->normal));
SDL_WidgetPropertiesOf(w,SET_PRESSED_IMAGE,IMG_Load(Button->pressed));
SDL_SignalConnect(w,"clicked",SONGDBUI_ChangeGroupClicked,NULL);
break;
}
Button=Button->next;
}
#endif
activesong[0]=-1;
activesong[1]=-1;
return sw;
}
static GtkWidget*
create_notebook_non_dragable_content (gchar **labels,
const gchar *group,
GtkPositionType pos)
{
GtkWidget *notebook, *title, *page, *action_widget;
notebook = gtk_notebook_new ();
gtk_widget_set_vexpand (notebook, TRUE);
gtk_widget_set_hexpand (notebook, TRUE);
action_widget = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_BUTTON);
g_signal_connect (action_widget, "clicked", G_CALLBACK (action_clicked_cb), notebook);
gtk_widget_show (action_widget);
gtk_notebook_set_action_widget (GTK_NOTEBOOK (notebook), action_widget, GTK_PACK_END);
g_signal_connect (notebook, "create-window",
G_CALLBACK (window_creation_function), NULL);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), pos);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 6);
gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), group);
while (*labels)
{
GtkWidget *button;
button = gtk_button_new_with_label (*labels);
/* Use GtkListBox since it bubbles up motion notify event, which can
* experience more issues than GtkBox. */
page = gtk_list_box_new ();
gtk_container_add (GTK_CONTAINER (page), button);
title = gtk_label_new (*labels);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, title);
gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook), page, TRUE);
gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (notebook), page, TRUE);
labels++;
}
g_signal_connect (GTK_NOTEBOOK (notebook), "page-reordered",
G_CALLBACK (on_page_reordered), NULL);
g_signal_connect_after (G_OBJECT (notebook), "drag-begin",
G_CALLBACK (on_notebook_drag_begin), NULL);
return notebook;
}
static void
page_holder_app_add_browser_cb (MidoriApp* app,
MidoriBrowser* browser,
MidoriExtension* extension)
{
GtkWidget* panel;
GtkWidget* notebook;
GtkWidget* toolbar;
GtkToolItem* toolitem;
panel = katze_object_get_object (browser, "panel");
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_RIGHT);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_widget_show (notebook);
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON);
gtk_widget_show (toolbar);
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_JUMP_TO);
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (page_holder_button_jump_to_clicked_cb), notebook);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
toolitem = gtk_separator_tool_item_new ();
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (toolitem), FALSE);
gtk_tool_item_set_expand (toolitem, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
gtk_widget_show (GTK_WIDGET (toolitem));
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ADD);
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (page_holder_button_add_clicked_cb), notebook);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
midori_panel_append_widget (MIDORI_PANEL (panel), notebook,
/* i18n: A panel showing a user specified web page */
STOCK_PAGE_HOLDER, _("Pageholder"), toolbar);
g_signal_connect (extension, "deactivate",
G_CALLBACK (page_holder_deactivate_cb), notebook);
g_object_unref (panel);
}
static WIDGET *
notebook_beginprop_get_widget(NotebookProperty *prop, PropDialog *dialog)
{
GtkWidget *notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook),GTK_POS_TOP);
gtk_container_set_border_width (GTK_CONTAINER(notebook), 1);
gtk_widget_show(notebook);
prop_dialog_add_raw(dialog,notebook);
prop_dialog_container_push(dialog,notebook);
prop_dialog_container_push(dialog,NULL); /* there must be a _PAGE soon */
return NULL; /* there is no single widget to add with a label next to it. */
}
int main( int argc, char **argv ) {
gtk_init( &argc, &argv );
GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( window ), "Using Multiple Containers" );
gtk_container_set_border_width( GTK_CONTAINER( window ), 10 );
gtk_widget_set_size_request( window, 640, 480 );
GtkWidget *notebook = gtk_notebook_new();
GtkWidget *one = gtk_label_new( "One" );
GtkWidget *two = gtk_label_new( "Two" );
GtkWidget *three = gtk_label_new( "Three" );
GtkWidget *four = gtk_label_new( "Four" );
GtkWidget *next = gtk_button_new_with_label( "Next" );
GtkWidget *prev = gtk_button_new_with_label( "Prev" );
GtkWidget *exit = gtk_button_new_with_label( "Exit" );
GtkWidget *vbox = gtk_vbox_new( TRUE, 10 );
GtkWidget *hbox = gtk_hbox_new( TRUE, 10 );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), next, one );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
next = gtk_button_new_with_label( "Next" );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), next, two );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
next = gtk_button_new_with_label( "Next" );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), next, three );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
next = gtk_button_new_with_label( "Next" );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), next, four );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_notebook_set_tab_pos( GTK_NOTEBOOK( notebook ), GTK_POS_TOP );
g_signal_connect( G_OBJECT( exit ), "clicked", G_CALLBACK( exit_pressed ), NULL );
g_signal_connect( G_OBJECT( prev ), "clicked", G_CALLBACK( prev_pressed ), (gpointer) notebook );
gtk_box_pack_end( GTK_BOX( hbox ), exit, TRUE, FALSE, 5 );
gtk_box_pack_end( GTK_BOX( hbox ), prev, TRUE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( vbox ), notebook, TRUE, TRUE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 10 );
g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( destroy ), NULL );
gtk_container_add( GTK_CONTAINER( window ), vbox );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
static GtkWidget *
nimf_settings_build_main_window (NimfSettings *nsettings)
{
GtkWidget *window;
GtkWidget *notebook;
GList *schema_list = NULL;
gchar **non_relocatable;
gint i;
window = gtk_application_window_new (nsettings->app);
gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
gtk_window_set_title (GTK_WINDOW (window), _("Nimf Settings"));
gtk_window_set_icon_name (GTK_WINDOW (window), "nimf");
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_LEFT);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_container_add (GTK_CONTAINER (window), notebook);
g_settings_schema_source_list_schemas (nsettings->schema_source, TRUE,
&non_relocatable, NULL);
for (i = 0; non_relocatable[i] != NULL; i++)
if (g_str_has_prefix (non_relocatable[i], "org.nimf"))
schema_list = g_list_prepend (schema_list, non_relocatable[i]);
for (schema_list = g_list_sort (schema_list, (GCompareFunc) on_comparison);
schema_list != NULL;
schema_list = schema_list->next)
{
NimfSettingsPage *page;
GtkWidget *scrolled_w;
scrolled_w = gtk_scrolled_window_new (NULL, NULL);
page = nimf_settings_page_new (nsettings,
(const gchar *) schema_list->data);
gtk_container_add (GTK_CONTAINER (scrolled_w), page->box);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), scrolled_w, page->label);
g_ptr_array_add (nsettings->pages, page);
}
g_strfreev (non_relocatable);
g_list_free (schema_list);
return window;
}
GtkWidget* create_proj_props_window (t_tea_project *p)
{
if (! p)
return NULL;
wnd_proj_props = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (wnd_proj_props), _("Project properties"));
GtkWidget *vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (wnd_proj_props), vbox1);
GtkWidget *notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK(notebook), GTK_POS_LEFT);
gtk_widget_show (notebook);
gtk_container_add (GTK_CONTAINER (vbox1), notebook);
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), mk_page_main (p), gtk_label_new (_("Main")));
GtkWidget *hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (vbox1), hbox1);
GtkWidget *bt_close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_widget_show (bt_close);
gtk_container_add (GTK_CONTAINER (hbox1), bt_close);
g_signal_connect (bt_close, "clicked", G_CALLBACK (cb_on_bt_close), wnd_proj_props);
t_ppair *pair = g_malloc (sizeof (t_ppair));
pair->a = wnd_proj_props;
pair->b = p;
GtkWidget *bt_apply = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_widget_show (bt_apply);
gtk_container_add (GTK_CONTAINER (hbox1), bt_apply);
gtk_window_set_position (GTK_WINDOW(wnd_proj_props), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW(wnd_proj_props), TRUE);
gtk_widget_show (wnd_proj_props);
return wnd_proj_props;
}
GtkNotebook* toolbar2___::book__(GtkBox* box2, char in) {
GtkNotebook* n = NULL;
GtkWidget *&nb = in == 'l' ? left_book_ : right_book_;
if(!nb) {
GtkWidget* w = gtk_notebook_new ();
n = GTK_NOTEBOOK (w);
gtk_notebook_set_tab_pos (n, GTK_POS_TOP);
gtk_notebook_set_scrollable (n, true);
if(in == 'l')
gtk_box_pack_start(box2,w,FALSE,FALSE,0);
else
gtk_box_pack_end(box2,w,FALSE,FALSE,0);
nb = w;
} else {
n = GTK_NOTEBOOK (nb);
}
return n;
}
static GtkWidget*
create_notebook (gchar **labels,
const gchar *group,
GtkPositionType pos)
{
GtkWidget *notebook, *title, *page, *action_widget;
notebook = gtk_notebook_new ();
gtk_widget_set_vexpand (notebook, TRUE);
gtk_widget_set_hexpand (notebook, TRUE);
action_widget = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_BUTTON);
g_signal_connect (action_widget, "clicked", G_CALLBACK (action_clicked_cb), notebook);
gtk_widget_show (action_widget);
gtk_notebook_set_action_widget (GTK_NOTEBOOK (notebook), action_widget, GTK_PACK_END);
g_signal_connect (notebook, "create-window",
G_CALLBACK (window_creation_function), NULL);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), pos);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 6);
gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), group);
while (*labels)
{
page = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (page), *labels);
title = gtk_label_new (*labels);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, title);
gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook), page, TRUE);
gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (notebook), page, TRUE);
labels++;
}
g_signal_connect (GTK_NOTEBOOK (notebook), "page-reordered",
G_CALLBACK (on_page_reordered), NULL);
g_signal_connect_after (G_OBJECT (notebook), "drag-begin",
G_CALLBACK (on_notebook_drag_begin), NULL);
return notebook;
}
