/**
* Create main dialog decorations (excluding notebook pages).
*/
static void imp_ldif_dialog_create() {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *vnbox;
GtkWidget *notebook;
GtkWidget *hbbox;
GtkWidget *btnPrev;
GtkWidget *btnNext;
GtkWidget *btnProceed;
GtkWidget *btnCancel;
GtkWidget *hsbox;
GtkWidget *statusbar;
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "importldif");
gtk_widget_set_size_request(window, IMPORTLDIF_WIDTH, IMPORTLDIF_HEIGHT );
gtk_container_set_border_width( GTK_CONTAINER(window), 0 );
gtk_window_set_title( GTK_WINDOW(window), _("Import LDIF file into Address Book") );
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(imp_ldif_delete_event),
NULL );
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(imp_ldif_key_pressed),
NULL );
vbox = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
vnbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4);
gtk_widget_show(vnbox);
gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0);
/* Notebook */
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), FALSE );
gtk_widget_show(notebook);
gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 6);
/* Status line */
hsbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
/* Button panel */
gtkut_stock_button_set_create(&hbbox,
&btnCancel, GTK_STOCK_CANCEL,
&btnPrev, GTK_STOCK_GO_BACK,
&btnNext, GTK_STOCK_GO_FORWARD);
btnProceed = gtk_button_new_with_mnemonic(_("Proceed"));
gtk_button_set_image(GTK_BUTTON(btnProceed),
gtk_image_new_from_stock(GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON));
gtkut_widget_set_can_default(btnProceed, TRUE);
gtk_box_pack_start(GTK_BOX(hbbox), btnProceed, TRUE, TRUE, 0);
gtk_widget_hide(btnProceed);
gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbbox), 2);
gtk_widget_grab_default(btnNext);
/* Button handlers */
g_signal_connect(G_OBJECT(btnPrev), "clicked",
G_CALLBACK(imp_ldif_prev), NULL);
g_signal_connect(G_OBJECT(btnNext), "clicked",
G_CALLBACK(imp_ldif_next), NULL);
g_signal_connect(G_OBJECT(btnProceed), "clicked",
G_CALLBACK(imp_ldif_next), NULL);
g_signal_connect(G_OBJECT(btnCancel), "clicked",
G_CALLBACK(imp_ldif_cancel), NULL);
gtk_widget_show_all(vbox);
impldif_dlg.window = window;
impldif_dlg.notebook = notebook;
impldif_dlg.btnPrev = btnPrev;
impldif_dlg.btnNext = btnNext;
impldif_dlg.btnProceed = btnProceed;
impldif_dlg.btnCancel = btnCancel;
impldif_dlg.statusbar = statusbar;
impldif_dlg.status_cid = gtk_statusbar_get_context_id(
GTK_STATUSBAR(statusbar), "Import LDIF Dialog" );
}
static void
bt_settings_dialog_init_ui (const BtSettingsDialog * self)
{
GtkWidget *box, *scrolled_window, *pages;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeIter tree_iter;
gtk_widget_set_name (GTK_WIDGET (self), "buzztrax settings");
//gtk_widget_set_size_request(GTK_WIDGET(self),800,600);
gtk_window_set_title (GTK_WINDOW (self), _("buzztrax settings"));
// add dialog commision widgets (okay, cancel)
gtk_dialog_add_buttons (GTK_DIALOG (self),
_("_OK"), GTK_RESPONSE_ACCEPT, _("_Cancel"), GTK_RESPONSE_REJECT, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (self), GTK_RESPONSE_ACCEPT);
// add widgets to the dialog content area
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (box), 6);
// add a list on the right and a notebook without tabs on the left
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_ETCHED_IN);
self->priv->settings_list = GTK_TREE_VIEW (gtk_tree_view_new ());
gtk_tree_view_set_headers_visible (self->priv->settings_list, FALSE);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_insert_column_with_attributes (self->priv->settings_list, -1,
NULL, renderer, "icon-name", COL_ICON_NAME, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT
(renderer), 1);
gtk_tree_view_insert_column_with_attributes (self->priv->settings_list, -1,
NULL, renderer, "text", COL_LABEL, NULL);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (self->
priv->settings_list), GTK_SELECTION_BROWSE);
gtk_container_add (GTK_CONTAINER (scrolled_window),
GTK_WIDGET (self->priv->settings_list));
gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (scrolled_window), FALSE, FALSE,
0);
g_signal_connect (self->priv->settings_list, "realize",
G_CALLBACK (on_settings_list_realize), (gpointer) scrolled_window);
g_signal_connect (self->priv->settings_list, "cursor-changed",
G_CALLBACK (on_settings_list_cursor_changed), (gpointer) self);
store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_LONG, G_TYPE_STRING);
//-- append entries for settings pages
gtk_list_store_append (store, &tree_iter);
gtk_list_store_set (store, &tree_iter,
COL_LABEL, _("Audio Devices"),
COL_ID, BT_SETTINGS_PAGE_AUDIO_DEVICES, COL_ICON_NAME, "audio-card", -1);
gtk_list_store_append (store, &tree_iter);
gtk_list_store_set (store, &tree_iter,
COL_LABEL, _("Directories"),
COL_ID, BT_SETTINGS_PAGE_DIRECTORIES, COL_ICON_NAME, "folder", -1);
gtk_list_store_append (store, &tree_iter);
gtk_list_store_set (store, &tree_iter,
COL_LABEL, _("Interaction Controller"),
COL_ID, BT_SETTINGS_PAGE_INTERACTION_CONTROLLER,
COL_ICON_NAME, "input-gaming", -1);
gtk_list_store_append (store, &tree_iter);
gtk_list_store_set (store, &tree_iter,
COL_LABEL, _("Playback Controller"),
COL_ID, BT_SETTINGS_PAGE_PLAYBACK_CONTROLLER,
COL_ICON_NAME, "media-playback-start", -1);
gtk_list_store_append (store, &tree_iter);
gtk_list_store_set (store, &tree_iter,
COL_LABEL, _("Shortcuts"),
COL_ID, BT_SETTINGS_PAGE_SHORTCUTS, COL_ICON_NAME, "input-keyboard", -1);
gtk_list_store_append (store, &tree_iter);
gtk_list_store_set (store, &tree_iter,
COL_LABEL, _("User interface"),
COL_ID, BT_SETTINGS_PAGE_UI, COL_ICON_NAME, "preferences-desktop-theme",
-1);
gtk_tree_view_set_model (self->priv->settings_list, GTK_TREE_MODEL (store));
g_object_unref (store); // drop with treeview
// add notebook
pages = gtk_notebook_new ();
self->priv->settings_pages = GTK_NOTEBOOK (pages);
gtk_widget_set_name (pages, "settings pages");
gtk_notebook_set_show_tabs (self->priv->settings_pages, FALSE);
gtk_notebook_set_show_border (self->priv->settings_pages, FALSE);
gtk_container_add (GTK_CONTAINER (box), pages);
// add audio device page
self->priv->audiodevices_page = bt_settings_page_audiodevices_new (pages);
gtk_container_add (GTK_CONTAINER (self->priv->settings_pages),
GTK_WIDGET (self->priv->audiodevices_page));
gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages),
BT_SETTINGS_PAGE_AUDIO_DEVICES), gtk_label_new (_("Audio Devices")));
// add directories page
self->priv->directories_page = bt_settings_page_directories_new (pages);
gtk_container_add (GTK_CONTAINER (self->priv->settings_pages),
GTK_WIDGET (self->priv->directories_page));
gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages),
BT_SETTINGS_PAGE_DIRECTORIES), gtk_label_new (_("Directories")));
// add interaction controller page
self->priv->interaction_controller_page =
bt_settings_page_interaction_controller_new (pages);
gtk_container_add (GTK_CONTAINER (self->priv->settings_pages),
GTK_WIDGET (self->priv->interaction_controller_page));
gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages),
BT_SETTINGS_PAGE_INTERACTION_CONTROLLER),
gtk_label_new (_("Interaction Controller")));
// add playback controller page
self->priv->playback_controller_page =
bt_settings_page_playback_controller_new (pages);
gtk_container_add (GTK_CONTAINER (self->priv->settings_pages),
GTK_WIDGET (self->priv->playback_controller_page));
gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages),
BT_SETTINGS_PAGE_PLAYBACK_CONTROLLER),
gtk_label_new (_("Playback Controller")));
// add shortcuts pags
self->priv->shortcuts_page = bt_settings_page_shortcuts_new (pages);
gtk_container_add (GTK_CONTAINER (self->priv->settings_pages),
GTK_WIDGET (self->priv->shortcuts_page));
gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages),
BT_SETTINGS_PAGE_SHORTCUTS), gtk_label_new (_("Shortcuts")));
// add ui page
self->priv->ui_page = bt_settings_page_ui_new (pages);
gtk_container_add (GTK_CONTAINER (self->priv->settings_pages),
GTK_WIDGET (self->priv->ui_page));
gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages),
gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages),
BT_SETTINGS_PAGE_UI), gtk_label_new (_("User Interface")));
/* TODO(ensonic): more settings
* - misc
* - initial song bpm (from, to)
* - cpu monitor (view menu?)
*/
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))),
box, TRUE, TRUE, 0);
}
static void
hildon_wizard_dialog_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
HildonWizardDialogPrivate *priv = HILDON_WIZARD_DIALOG_GET_PRIVATE (object);
GtkDialog *dialog = GTK_DIALOG (object);
g_assert (priv);
switch (property_id) {
case PROP_AUTOTITLE:
priv->autotitle = g_value_get_boolean (value);
if (priv->autotitle &&
priv->wizard_name &&
priv->notebook)
create_title (HILDON_WIZARD_DIALOG (object));
else if (priv->wizard_name)
gtk_window_set_title (GTK_WINDOW (object), priv->wizard_name);
break;
case PROP_NAME:
/* Set new wizard name. This name will appear in titlebar */
if (priv->wizard_name)
g_free (priv->wizard_name);
gchar *str = (gchar *) g_value_get_string (value);
g_return_if_fail (str != NULL);
priv->wizard_name = g_strdup (str);
/* We need notebook in order to create title, since page information
is used in title generation */
if (priv->notebook && priv->autotitle)
create_title (HILDON_WIZARD_DIALOG (object));
break;
case PROP_NOTEBOOK: {
GtkNotebook *book = GTK_NOTEBOOK (g_value_get_object (value));
g_return_if_fail (book != NULL);
priv->notebook = book;
/* Set the default properties for the notebook (disable tabs,
* and remove borders) to make it look like a nice wizard widget */
gtk_notebook_set_show_tabs (priv->notebook, FALSE);
gtk_notebook_set_show_border (priv->notebook, FALSE);
gtk_box_pack_start_defaults (GTK_BOX (dialog->vbox), GTK_WIDGET (priv->notebook));
/* Show the notebook so that a gtk_widget_show on the dialog is
* all that is required to display the dialog correctly */
gtk_widget_show (GTK_WIDGET (priv->notebook));
/* Update dialog title to reflect current page stats etc */
if (priv->wizard_name && priv->autotitle)
create_title (HILDON_WIZARD_DIALOG (object));
} break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void build_mainwindow(void)
{
guint ic;
uri_regex_count = G_N_ELEMENTS(uri_patterns);
uri_regex = g_new0(GRegex*, uri_regex_count);
for(ic = 0; ic < uri_regex_count; ++ic)
{
GError *error = NULL;
uri_regex[ic] = g_regex_new(uri_patterns[ic].pattern,
uri_patterns[ic].flags | G_REGEX_OPTIMIZE, 0, &error);
if(error)
{
g_message("%s", error->message);
g_error_free (error);
}
}
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable(mainwindow, TRUE);
gtk_widget_set_size_request(mainwindow, conf_get_width(), conf_get_height());
gtk_window_set_decorated(GTK_WINDOW(mainwindow), FALSE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_resizable(GTK_WINDOW(mainwindow), TRUE);
mainwindow_reset_position();
fullscreen = FALSE;
toggled = FALSE;
GtkAccelGroup* accel_group;
GClosure *new_tab, *delete_tab, *next_tab, *prev_tab, *delete_all,
*maximize, *copy, *paste;
GClosure *goto_tab_closure[10];
long i;
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(mainwindow), accel_group);
maximize = g_cclosure_new_swap(G_CALLBACK(mainwindow_toggle_fullscreen),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_F11, 0,
GTK_ACCEL_VISIBLE, maximize);
new_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_new_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 't', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, new_tab);
delete_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_delete_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'w', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_tab);
next_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_next_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Up, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, next_tab);
prev_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_prev_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Down, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, prev_tab);
delete_all = g_cclosure_new_swap(G_CALLBACK(mainwindow_destroy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'q', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_all);
/* tab hotkeys, inspired by Tilda -- thanks to castorinop for the patch */
for(i = 0; i < 10; i++)
{
goto_tab_closure[i] = g_cclosure_new_swap(G_CALLBACK(mainwindow_goto_tab),
(gpointer) i, NULL);
gtk_accel_group_connect(accel_group, '0' + ((i+1)%10), GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE, goto_tab_closure[i]);
}
copy = g_cclosure_new_swap(G_CALLBACK(mainwindow_copy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'c', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, copy);
paste = g_cclosure_new_swap(G_CALLBACK(mainwindow_paste),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'v', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, paste);
activetab = -1;
tabcount = 0;
GtkVBox* mainbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
tabbar = GTK_NOTEBOOK(gtk_notebook_new());
g_signal_connect(G_OBJECT(tabbar), "switch-page",
G_CALLBACK(mainwindow_switch_tab), NULL);
if(conf_get_opacity() < 100)
{
GdkScreen *screen = gdk_screen_get_default();
GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen);
screen_is_composited = (colormap != NULL
&& gdk_screen_is_composited(screen));
if(screen_is_composited)
{
gtk_widget_set_colormap(GTK_WIDGET(mainwindow), colormap);
gdk_screen_set_default_colormap(screen, colormap);
}
}
gtk_box_pack_start(GTK_BOX(mainbox), GTK_WIDGET(tabbar), TRUE, TRUE, 0);
mainwindow_create_tab();
gtk_widget_show_all(GTK_WIDGET(mainbox));
gtk_container_add(GTK_CONTAINER(mainwindow), GTK_WIDGET(mainbox));
int border = conf_get_border();
if(border == BORDER_THIN)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 1);
else if(border == BORDER_THICK)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5);
if(border != BORDER_NONE)
g_signal_connect(G_OBJECT(mainwindow), "expose-event",
G_CALLBACK(mainwindow_expose_event), NULL);
if(conf_get_auto_hide())
g_signal_connect(G_OBJECT(mainwindow), "focus-out-event",
G_CALLBACK(mainwindow_focus_out_event), NULL);
g_signal_connect(G_OBJECT(mainwindow), "show", G_CALLBACK(mainwindow_show),
NULL);
g_signal_connect(G_OBJECT(mainwindow), "destroy",
G_CALLBACK(mainwindow_destroy), NULL);
g_signal_connect_after(G_OBJECT(tabbar), "button_press_event",
G_CALLBACK(mainwindow_notebook_clicked), NULL);
gtk_notebook_set_show_border(tabbar, FALSE);
gtk_notebook_set_scrollable(tabbar, TRUE);
if (conf_get_show_tab() == TABS_ONE|| conf_get_show_tab() == TABS_NEVER)
gtk_notebook_set_show_tabs(tabbar, FALSE);
gtk_notebook_set_tab_pos(tabbar, conf_get_tab_pos());
gtk_notebook_set_homogeneous_tabs(tabbar, FALSE);
XSetErrorHandler(handle_x_error);
init_key();
grab_key();
g_thread_new("stjerm", (GThreadFunc)wait_key, NULL);
// If stjerm has been started for the first time with --toggle, then
// show the window straight away. Make haste!
if(conf_get_toggled()) {
mainwindow_toggle(1);
}
}
static void imp_ldif_dialog_create() {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *vnbox;
GtkWidget *notebook;
GtkWidget *hbbox;
GtkWidget *btnPrev;
GtkWidget *btnNext;
GtkWidget *btnCancel;
GtkWidget *hsbox;
GtkWidget *statusbar;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window, IMPORTLDIF_WIDTH, IMPORTLDIF_HEIGHT );
gtk_container_set_border_width( GTK_CONTAINER(window), 0 );
gtk_window_set_title( GTK_WINDOW(window), _("Import LDIF file into Address Book") );
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(imp_ldif_delete_event), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(imp_ldif_key_pressed), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
vbox = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
vnbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4);
gtk_widget_show(vnbox);
gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0);
/* Notebook */
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), FALSE );
gtk_widget_show(notebook);
gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 6);
/* Status line */
hsbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, 0);
statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, 0);
/* Button panel */
gtkut_stock_button_set_create(&hbbox, &btnNext, _("Next"),
&btnPrev, _("Prev"),
&btnCancel, GTK_STOCK_CANCEL);
gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(hbbox), btnCancel,
TRUE);
gtkut_box_set_reverse_order(GTK_BOX(hbbox), FALSE);
gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbbox), 2);
gtk_widget_grab_default(btnNext);
/* Button handlers */
g_signal_connect(G_OBJECT(btnPrev), "clicked",
G_CALLBACK(imp_ldif_prev), NULL);
g_signal_connect(G_OBJECT(btnNext), "clicked",
G_CALLBACK(imp_ldif_next), NULL);
g_signal_connect(G_OBJECT(btnCancel), "clicked",
G_CALLBACK(imp_ldif_cancel), NULL);
gtk_widget_show_all(vbox);
impldif_dlg.window = window;
impldif_dlg.notebook = notebook;
impldif_dlg.btnPrev = btnPrev;
impldif_dlg.btnNext = btnNext;
impldif_dlg.btnCancel = btnCancel;
impldif_dlg.statusbar = statusbar;
impldif_dlg.status_cid = gtk_statusbar_get_context_id(
GTK_STATUSBAR(statusbar), "Import LDIF Dialog" );
}
GtkWindow* PrefsDlg::BuildDialog(){
PreferencesDialog_addInterfacePreferences( FreeCaller1<PreferencesPage&, Interface_constructPreferences>() );
Mouse_registerPreferencesPage();
GtkWindow* dialog = create_floating_window( "NetRadiant Preferences", m_parent );
{
GtkWidget* mainvbox = gtk_vbox_new( FALSE, 5 );
gtk_container_add( GTK_CONTAINER( dialog ), mainvbox );
gtk_container_set_border_width( GTK_CONTAINER( mainvbox ), 5 );
gtk_widget_show( mainvbox );
{
GtkWidget* hbox = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_end( GTK_BOX( mainvbox ), hbox, FALSE, TRUE, 0 );
{
GtkButton* button = create_dialog_button( "OK", G_CALLBACK( dialog_button_ok ), &m_modal );
gtk_box_pack_end( GTK_BOX( hbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
}
{
GtkButton* button = create_dialog_button( "Cancel", G_CALLBACK( dialog_button_cancel ), &m_modal );
gtk_box_pack_end( GTK_BOX( hbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
}
{
GtkButton* button = create_dialog_button( "Clean", G_CALLBACK( OnButtonClean ), this );
gtk_box_pack_end( GTK_BOX( hbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
}
}
{
GtkWidget* hbox = gtk_hbox_new( FALSE, 5 );
gtk_box_pack_start( GTK_BOX( mainvbox ), hbox, TRUE, TRUE, 0 );
gtk_widget_show( hbox );
{
GtkWidget* sc_win = gtk_scrolled_window_new( 0, 0 );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sc_win ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
gtk_box_pack_start( GTK_BOX( hbox ), sc_win, FALSE, FALSE, 0 );
gtk_widget_show( sc_win );
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( sc_win ), GTK_SHADOW_IN );
// prefs pages notebook
m_notebook = gtk_notebook_new();
// hide the notebook tabs since its not supposed to look like a notebook
gtk_notebook_set_show_tabs( GTK_NOTEBOOK( m_notebook ), FALSE );
gtk_box_pack_start( GTK_BOX( hbox ), m_notebook, TRUE, TRUE, 0 );
gtk_widget_show( m_notebook );
{
GtkTreeStore* store = gtk_tree_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER );
GtkWidget* view = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) );
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
{
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "Preferences", renderer, "text", 0, NULL );
gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
}
{
GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
g_signal_connect( G_OBJECT( selection ), "changed", G_CALLBACK( treeSelection ), this );
}
gtk_widget_show( view );
gtk_container_add( GTK_CONTAINER( sc_win ), view );
{
/********************************************************************/
/* Add preference tree options */
/********************************************************************/
// Front page...
//GtkWidget* front =
PreferencePages_addPage( m_notebook, "Front Page" );
{
GtkWidget* global = PreferencePages_addPage( m_notebook, "Global Preferences" );
{
PreferencesPage preferencesPage( *this, getVBox( global ) );
Global_constructPreferences( preferencesPage );
}
GtkTreeIter group = PreferenceTree_appendPage( store, 0, "Global", global );
{
GtkWidget* game = PreferencePages_addPage( m_notebook, "Game" );
PreferencesPage preferencesPage( *this, getVBox( game ) );
g_GamesDialog.CreateGlobalFrame( preferencesPage );
PreferenceTree_appendPage( store, &group, "Game", game );
}
}
{
GtkWidget* interfacePage = PreferencePages_addPage( m_notebook, "Interface Preferences" );
{
PreferencesPage preferencesPage( *this, getVBox( interfacePage ) );
PreferencesPageCallbacks_constructPage( g_interfacePreferences, preferencesPage );
}
GtkTreeIter group = PreferenceTree_appendPage( store, 0, "Interface", interfacePage );
PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
PreferenceGroupCallbacks_constructGroup( g_interfaceCallbacks, preferenceGroup );
}
{
GtkWidget* display = PreferencePages_addPage( m_notebook, "Display Preferences" );
{
PreferencesPage preferencesPage( *this, getVBox( display ) );
PreferencesPageCallbacks_constructPage( g_displayPreferences, preferencesPage );
}
GtkTreeIter group = PreferenceTree_appendPage( store, 0, "Display", display );
PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
PreferenceGroupCallbacks_constructGroup( g_displayCallbacks, preferenceGroup );
}
{
GtkWidget* settings = PreferencePages_addPage( m_notebook, "General Settings" );
{
PreferencesPage preferencesPage( *this, getVBox( settings ) );
PreferencesPageCallbacks_constructPage( g_settingsPreferences, preferencesPage );
}
GtkTreeIter group = PreferenceTree_appendPage( store, 0, "Settings", settings );
PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group );
PreferenceGroupCallbacks_constructGroup( g_settingsCallbacks, preferenceGroup );
}
}
gtk_tree_view_expand_all( GTK_TREE_VIEW( view ) );
g_object_unref( G_OBJECT( store ) );
}
}
}
}
gtk_notebook_set_page( GTK_NOTEBOOK( m_notebook ), 0 );
return dialog;
}
static void
ui_formgrid_init (UiFormGrid *formgrid)
{
GtkWidget *sw;
GtkWidget *hbox, *button;
formgrid->priv = g_new0 (UiFormGridPriv, 1);
formgrid->priv->raw_grid = NULL;
formgrid->priv->info = NULL;
formgrid->priv->flags = GDAUI_DATA_PROXY_INFO_CURRENT_ROW | GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS;
formgrid->priv->tcnc = NULL;
formgrid->priv->autoupdate = TRUE;
formgrid->priv->autoupdate_possible = FALSE;
formgrid->priv->scroll_form = FALSE;
formgrid->priv->compute_mod_stmt = FALSE;
formgrid->priv->refresh_callback = NULL;
formgrid->priv->refresh_user_data = NULL;
gtk_orientable_set_orientation (GTK_ORIENTABLE (formgrid), GTK_ORIENTATION_VERTICAL);
/* notebook */
formgrid->priv->nb = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (formgrid->priv->nb), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (formgrid->priv->nb), FALSE);
gtk_box_pack_start (GTK_BOX (formgrid), formgrid->priv->nb, TRUE, TRUE, 0);
gtk_widget_show (formgrid->priv->nb);
/* grid on 1st page of notebook, not added there */
formgrid->priv->raw_grid = gdaui_raw_grid_new (NULL);
gdaui_data_proxy_column_show_actions (GDAUI_DATA_PROXY (formgrid->priv->raw_grid), -1, FALSE);
g_signal_connect (formgrid->priv->raw_grid, "populate-popup",
G_CALLBACK (form_grid_populate_popup_cb), formgrid);
/* form on the 2nd page of the notebook, not added there */
formgrid->priv->raw_form = gdaui_raw_form_new (NULL);
gdaui_data_proxy_column_show_actions (GDAUI_DATA_PROXY (formgrid->priv->raw_form), -1, FALSE);
g_signal_connect (formgrid->priv->raw_form, "populate-popup",
G_CALLBACK (form_grid_populate_popup_cb), formgrid);
/* info widget and toggle button at last */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (formgrid), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
/* button to toggle between auto update and not */
button = gtk_toggle_button_new ();
GtkWidget *img = gtk_image_new_from_icon_name (_("_Execute"), GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (button), img);
formgrid->priv->autoupdate_toggle = button;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), formgrid->priv->autoupdate);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (form_grid_autoupdate_cb), formgrid);
gtk_widget_set_tooltip_text (button, _("Enable or disable auto update of data"));
/* Proxy info */
formgrid->priv->info = gdaui_data_proxy_info_new (GDAUI_DATA_PROXY (formgrid->priv->raw_grid),
formgrid->priv->flags |
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_CHUNCK_CHANGE_BUTTONS);
button = GTK_WIDGET (gtk_toggle_tool_button_new ());
gtk_widget_set_tooltip_text (button, _("Toggle between grid and form presentations"));
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (button), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (formgrid->priv->info), GTK_TOOL_ITEM (button), 0);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (form_grid_toggled_cb), formgrid);
/* refresh button, don't show it yet */
button = GTK_WIDGET (gtk_tool_button_new (NULL, NULL));
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (button), "view-refresh-symbolic");
gtk_widget_set_tooltip_text (button, _("Refresh data"));
gtk_toolbar_insert (GTK_TOOLBAR (formgrid->priv->info), GTK_TOOL_ITEM (button), 0);
formgrid->priv->refresh_button = button;
/* keep data in sync */
g_signal_connect (formgrid->priv->raw_grid, "selection-changed",
G_CALLBACK (selection_changed_cb), formgrid);
g_signal_connect (formgrid->priv->raw_form, "selection-changed",
G_CALLBACK (selection_changed_cb), formgrid);
}
static GtkWidget *
ivcal_getwidget (EImport *ei,
EImportTarget *target,
EImportImporter *im)
{
EShell *shell;
ESourceRegistry *registry;
GtkWidget *vbox, *hbox, *first = NULL;
GSList *group = NULL;
gint i;
GtkWidget *nb;
shell = e_shell_get_default ();
registry = e_shell_get_registry (shell);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6);
nb = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (nb), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (nb), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), nb, TRUE, TRUE, 6);
/* Type of icalendar items */
for (i = 0; import_type_map[i] != -1; i++) {
GtkWidget *selector, *rb, *create_button, *vbox;
GtkWidget *scrolled;
struct _selector_data *sd;
const gchar *extension_name;
const gchar *create_label;
switch (import_type_map[i]) {
case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
extension_name = E_SOURCE_EXTENSION_CALENDAR;
create_label = _("Cre_ate new calendar");
break;
case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
extension_name = E_SOURCE_EXTENSION_TASK_LIST;
create_label = _("Cre_ate new task list");
break;
default:
g_warn_if_reached ();
continue;
}
selector = e_source_selector_new (registry, extension_name);
e_source_selector_set_show_toggles (E_SOURCE_SELECTOR (selector), FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vbox, NULL);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scrolled, GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add ((GtkContainer *) scrolled, selector);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
create_button = gtk_button_new_with_mnemonic (create_label);
g_object_set_data (G_OBJECT (create_button), "source-type", GINT_TO_POINTER (import_type_map[i]));
g_object_set (G_OBJECT (create_button),
"hexpand", FALSE,
"halign", GTK_ALIGN_END,
"vexpand", FALSE,
"valign", GTK_ALIGN_START,
NULL);
gtk_box_pack_start (GTK_BOX (vbox), create_button, FALSE, FALSE, 0);
g_signal_connect (create_button, "clicked", G_CALLBACK (create_calendar_clicked_cb), selector);
g_signal_connect (
selector, "primary_selection_changed",
G_CALLBACK (primary_selection_changed_cb), target);
rb = gtk_radio_button_new_with_label (group, _(import_type_strings[i]));
gtk_box_pack_start (GTK_BOX (hbox), rb, FALSE, FALSE, 6);
sd = g_malloc0 (sizeof (*sd));
sd->target = target;
sd->selector = selector;
sd->notebook = nb;
sd->page = i;
g_object_set_data_full ((GObject *) rb, "selector-data", sd, g_free);
g_signal_connect (
rb, "toggled",
G_CALLBACK (button_toggled_cb), sd);
if (!group)
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb));
if (first == NULL) {
/* Set primary-source */
primary_selection_changed_cb (E_SOURCE_SELECTOR (selector), target);
g_datalist_set_data (&target->data, "primary-type", GINT_TO_POINTER (import_type_map[i]));
first = rb;
}
}
if (first)
gtk_toggle_button_set_active ((GtkToggleButton *) first, TRUE);
gtk_widget_show_all (vbox);
return vbox;
}
/**
* Create and run preferences dialog.
*
* The preferences dialog contains a GtkNoteBook, which is used to group
* the various configuration parts/modules (General, Modules, Interfaces, ...).
* Each configuration part can contain several subgroups that are managed
* by the module itself. As an example, consider the "Modules" tab which
* could have the following sub-groups: General, List View, Map View and so on.
* The tabs of the notebook are invisible, instead a vertical icon list
* placed on the left of the notebook is used to navigate through the
* notebook pages. The icon list is actually impemented using pixmap buttons
* in a button box. Using something like the GtkIconView would have been better
* but that seems to be rather useless when packed into a box.
*/
void sat_pref_run()
{
GtkWidget *nbook; /* notebook widget */
GtkWidget *hbox; /* horizontal box */
GtkWidget *butbox;
GtkWidget *genbut, *modbut, *ifbut, *predbut;
gchar *iconfile;
gint response;
/* Create notebook and add individual pages.
The individual pages will need the GKeyFile
*/
nbook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(nbook),
sat_pref_general_create(),
gtk_label_new(_("General")));
gtk_notebook_append_page(GTK_NOTEBOOK(nbook),
sat_pref_modules_create(NULL),
gtk_label_new(_("Modules")));
gtk_notebook_append_page(GTK_NOTEBOOK(nbook),
sat_pref_interfaces_create(),
gtk_label_new(_("Interfaces")));
gtk_notebook_append_page(GTK_NOTEBOOK(nbook),
sat_pref_predict_create(),
gtk_label_new(_("Predict")));
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(nbook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(nbook), FALSE);
/* create a button box and add the buttons one by one */
genbut = gpredict_vpixmap_button("gpredict-sat-pref.png",
_("General"), NULL);
gtk_button_set_relief(GTK_BUTTON(genbut), GTK_RELIEF_NONE);
g_object_set_data(G_OBJECT(genbut), "page",
GINT_TO_POINTER(NBOOK_PAGE_GENERAL));
g_signal_connect(G_OBJECT(genbut), "clicked",
G_CALLBACK(button_press_cb), nbook);
modbut = gpredict_vpixmap_button("gpredict-sat-list.png",
_("Modules"), NULL);
gtk_button_set_relief(GTK_BUTTON(modbut), GTK_RELIEF_NONE);
g_object_set_data(G_OBJECT(modbut), "page",
GINT_TO_POINTER(NBOOK_PAGE_MODULES));
g_signal_connect(G_OBJECT(modbut), "clicked",
G_CALLBACK(button_press_cb), nbook);
ifbut = gpredict_vpixmap_button("gpredict-oscilloscope.png",
_("Interfaces"), NULL);
gtk_button_set_relief(GTK_BUTTON(ifbut), GTK_RELIEF_NONE);
g_object_set_data(G_OBJECT(ifbut), "page",
GINT_TO_POINTER(NBOOK_PAGE_INTERFACE));
g_signal_connect(G_OBJECT(ifbut), "clicked",
G_CALLBACK(button_press_cb), nbook);
predbut = gpredict_vpixmap_button("gpredict-calendar.png",
_("Predict"), NULL);
gtk_button_set_relief(GTK_BUTTON(predbut), GTK_RELIEF_NONE);
g_object_set_data(G_OBJECT(predbut), "page",
GINT_TO_POINTER(NBOOK_PAGE_PREDICT));
g_signal_connect(G_OBJECT(predbut), "clicked",
G_CALLBACK(button_press_cb), nbook);
butbox = gtk_vbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(butbox), GTK_BUTTONBOX_START);
gtk_container_add(GTK_CONTAINER(butbox), genbut);
gtk_container_add(GTK_CONTAINER(butbox), modbut);
gtk_container_add(GTK_CONTAINER(butbox), ifbut);
gtk_container_add(GTK_CONTAINER(butbox), predbut);
/* create horizontal box which will contain the icon list on the left side
and the notebook on the right side.
*/
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), butbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), nbook, TRUE, TRUE, 0);
gtk_widget_show_all(hbox);
/* create and display preferences window */
window = gtk_dialog_new_with_buttons(_("Gpredict Preferences :: General"),
GTK_WINDOW(app),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT, NULL);
iconfile = icon_file_name("gpredict-sat-pref.png");
gtk_window_set_icon_from_file(GTK_WINDOW(window), iconfile, NULL);
g_free(iconfile);
gtk_box_pack_start(GTK_BOX
(gtk_dialog_get_content_area(GTK_DIALOG(window))),
hbox, TRUE, TRUE, 0);
gtk_box_set_spacing(GTK_BOX
(gtk_dialog_get_content_area(GTK_DIALOG(window))), 10);
gtk_button_clicked(GTK_BUTTON(genbut));
response = gtk_dialog_run(GTK_DIALOG(window));
switch (response)
{
case GTK_RESPONSE_ACCEPT:
sat_pref_general_ok();
sat_pref_modules_ok(NULL);
sat_pref_interfaces_ok();
sat_pref_predict_ok();
sat_cfg_save();
break;
default:
sat_pref_general_cancel();
sat_pref_modules_cancel(NULL);
sat_pref_interfaces_cancel();
sat_pref_predict_cancel();
break;
}
gtk_widget_destroy(window);
}
GtkWidget *
do_search_entry (GtkWidget *do_widget)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *find_button;
GtkWidget *cancel_button;
if (!window)
{
window = gtk_dialog_new_with_buttons ("Search Entry",
GTK_WINDOW (do_widget),
0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_NONE,
NULL);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (search_entry_destroyed), &window);
vbox = gtk_vbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "Search entry demo");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
/* Create our entry */
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
/* Create the find and cancel buttons */
notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), notebook, FALSE, FALSE, 0);
find_button = gtk_button_new_with_label ("Find");
g_signal_connect (find_button, "clicked",
G_CALLBACK (start_search), entry);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), find_button, NULL);
gtk_widget_show (find_button);
cancel_button = gtk_button_new_with_label ("Cancel");
g_signal_connect (cancel_button, "clicked",
G_CALLBACK (stop_search), NULL);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), cancel_button, NULL);
gtk_widget_show (cancel_button);
/* Set up the search icon */
search_by_name (NULL, GTK_ENTRY (entry));
/* Set up the clear icon */
gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_CLEAR);
text_changed_cb (GTK_ENTRY (entry), NULL, find_button);
g_signal_connect (entry, "icon-press",
G_CALLBACK (icon_press_cb), NULL);
g_signal_connect (entry, "notify::text",
G_CALLBACK (text_changed_cb), find_button);
g_signal_connect (entry, "activate",
G_CALLBACK (activate_cb), NULL);
/* Create the menu */
menu = create_search_menu (entry);
gtk_menu_attach_to_widget (GTK_MENU (menu), entry, NULL);
/* add accessible alternatives for icon functionality */
g_signal_connect (entry, "populate-popup",
G_CALLBACK (entry_populate_popup), NULL);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (menu);
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
void
caja_navigation_window_pane_setup (CajaNavigationWindowPane *pane)
{
GtkWidget *hbox;
CajaEntry *entry;
GtkSizeGroup *header_size_group;
pane->widget = gtk_vbox_new (FALSE, 0);
hbox = gtk_hbox_new (FALSE, 12);
pane->location_bar = hbox;
gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
gtk_box_pack_start (GTK_BOX (pane->widget), hbox,
FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* the header size group ensures that the location bar has the same height as the sidebar header */
header_size_group = CAJA_NAVIGATION_WINDOW (CAJA_WINDOW_PANE (pane)->window)->details->header_size_group;
gtk_size_group_add_widget (header_size_group, pane->location_bar);
pane->location_button = location_button_create (pane);
gtk_box_pack_start (GTK_BOX (hbox), pane->location_button, FALSE, FALSE, 0);
gtk_widget_show (pane->location_button);
pane->path_bar = g_object_new (CAJA_TYPE_PATH_BAR, NULL);
gtk_widget_show (pane->path_bar);
g_signal_connect_object (pane->path_bar, "path_clicked",
G_CALLBACK (path_bar_location_changed_callback), pane, 0);
g_signal_connect_object (pane->path_bar, "path_set",
G_CALLBACK (path_bar_path_set_callback), pane, 0);
gtk_box_pack_start (GTK_BOX (hbox),
pane->path_bar,
TRUE, TRUE, 0);
pane->navigation_bar = caja_location_bar_new (pane);
g_signal_connect_object (pane->navigation_bar, "location_changed",
G_CALLBACK (navigation_bar_location_changed_callback), pane, 0);
g_signal_connect_object (pane->navigation_bar, "cancel",
G_CALLBACK (navigation_bar_cancel_callback), pane, 0);
entry = caja_location_bar_get_entry (CAJA_LOCATION_BAR (pane->navigation_bar));
g_signal_connect (entry, "focus-in-event",
G_CALLBACK (navigation_bar_focus_in_callback), pane);
gtk_box_pack_start (GTK_BOX (hbox),
pane->navigation_bar,
TRUE, TRUE, 0);
pane->search_bar = caja_search_bar_new ();
g_signal_connect_object (pane->search_bar, "activate",
G_CALLBACK (search_bar_activate_callback), pane, 0);
g_signal_connect_object (pane->search_bar, "cancel",
G_CALLBACK (search_bar_cancel_callback), pane, 0);
g_signal_connect_object (pane->search_bar, "focus-in",
G_CALLBACK (search_bar_focus_in_callback), pane, 0);
gtk_box_pack_start (GTK_BOX (hbox),
pane->search_bar,
TRUE, TRUE, 0);
pane->notebook = g_object_new (CAJA_TYPE_NOTEBOOK, NULL);
gtk_box_pack_start (GTK_BOX (pane->widget), pane->notebook,
TRUE, TRUE, 0);
g_signal_connect (pane->notebook,
"tab-close-request",
G_CALLBACK (notebook_tab_close_requested),
pane);
g_signal_connect_after (pane->notebook,
"button_press_event",
G_CALLBACK (notebook_button_press_cb),
pane);
g_signal_connect (pane->notebook, "popup-menu",
G_CALLBACK (notebook_popup_menu_cb),
pane);
g_signal_connect (pane->notebook,
"switch-page",
G_CALLBACK (notebook_switch_page_cb),
pane);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (pane->notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (pane->notebook), FALSE);
gtk_widget_show (pane->notebook);
gtk_container_set_border_width (GTK_CONTAINER (pane->notebook), 0);
/* Ensure that the view has some minimal size and that other parts
* of the UI (like location bar and tabs) don't request more and
* thus affect the default position of the split view paned.
*/
gtk_widget_set_size_request (pane->widget, 60, 60);
}
static void
book_shell_content_constructed (GObject *object)
{
EBookShellContentPrivate *priv;
EShellView *shell_view;
EShellWindow *shell_window;
EShellContent *shell_content;
EShellTaskbar *shell_taskbar;
GtkWidget *container;
GtkWidget *widget;
priv = E_BOOK_SHELL_CONTENT_GET_PRIVATE (object);
/* Chain up to parent's constructed() method. */
G_OBJECT_CLASS (e_book_shell_content_parent_class)->constructed (object);
shell_content = E_SHELL_CONTENT (object);
shell_view = e_shell_content_get_shell_view (shell_content);
shell_window = e_shell_view_get_shell_window (shell_view);
shell_taskbar = e_shell_view_get_shell_taskbar (shell_view);
container = GTK_WIDGET (object);
widget = e_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (container), widget);
priv->paned = g_object_ref (widget);
gtk_widget_show (widget);
g_object_bind_property (
object, "orientation",
widget, "orientation",
G_BINDING_SYNC_CREATE);
container = widget;
widget = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (widget), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (widget), FALSE);
gtk_paned_pack1 (GTK_PANED (container), widget, TRUE, FALSE);
priv->notebook = g_object_ref (widget);
gtk_widget_show (widget);
widget = eab_contact_display_new ();
eab_contact_display_set_mode (
EAB_CONTACT_DISPLAY (widget),
EAB_CONTACT_DISPLAY_RENDER_NORMAL);
eab_contact_display_set_show_maps (
EAB_CONTACT_DISPLAY (widget),
priv->preview_show_maps);
g_object_bind_property (
object, "preview-show-maps",
widget, "show-maps",
G_BINDING_SYNC_CREATE);
gtk_widget_show (widget);
g_signal_connect_swapped (
widget, "send-message",
G_CALLBACK (book_shell_content_send_message_cb), object);
g_signal_connect_swapped (
widget, "status-message",
G_CALLBACK (e_shell_taskbar_set_message),
shell_taskbar);
widget = e_preview_pane_new (E_WEB_VIEW (widget));
gtk_paned_pack2 (GTK_PANED (container), widget, FALSE, FALSE);
priv->preview_pane = g_object_ref (widget);
gtk_widget_show (widget);
g_object_bind_property (
object, "preview-visible",
widget, "visible",
G_BINDING_SYNC_CREATE);
/* Restore pane positions from the last session once
* the shell view is fully initialized and visible. */
g_signal_connect (
shell_window, "shell-view-created::addressbook",
G_CALLBACK (book_shell_content_restore_state_cb),
shell_content);
}
void user_install_dialog_create(UserInstallCallback callback)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *ebox;
GtkWidget *table;
GtkWidget *darea;
GtkWidget *page;
GtkWidget *sep;
PangoFontDescription *large_font_desc;
gchar* Version_S = g_strdup_printf("%d.%d.%d",MAJOR_VERSION,MINOR_VERSION,MICRO_VERSION);
gchar* temp = NULL;
dialog = user_install_dialog = gtk_dialog_new ();
gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_CENTER);
gtk_window_set_title(>K_DIALOG(dialog)->window,_("Gabedit User Installation"));
gtk_widget_realize (dialog);
set_icone(GTK_WIDGET(dialog));
action_area = gtk_hbox_new(FALSE, 8);
gtk_box_set_homogeneous(GTK_BOX(action_area), FALSE);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), action_area);
/* B/W Style for the page contents */
page_style = gtk_style_copy(gtk_widget_get_default_style());
colormap = gtk_widget_get_colormap(dialog);
black_color.red = 0;
black_color.green = 0;
black_color.blue = 0;
gdk_colormap_alloc_color (colormap, &black_color, FALSE, TRUE);
white_color.red = 65535;
white_color.green = 65535;
white_color.blue = 65535;
gdk_colormap_alloc_color (colormap, &white_color, FALSE, TRUE);
page_style->fg[GTK_STATE_NORMAL] = black_color;
page_style->text[GTK_STATE_NORMAL] = black_color;
page_style->bg[GTK_STATE_NORMAL] = white_color;
/*
gdk_font_unref(page_style->font);
page_style->font = dialog->style->font;
gdk_font_ref(page_style->font);
*/
/* B/Colored Style for the page title */
title_style = gtk_style_copy(page_style);
if (gdk_color_parse("royal blue", &title_color) && gdk_colormap_alloc_color(colormap, &title_color, FALSE, TRUE))
{
title_style->bg[GTK_STATE_NORMAL] = title_color;
}
large_font_desc = pango_font_description_from_string ("sans bold 20");
if (large_font_desc)
{
title_style->font_desc = large_font_desc;
}
/* W/W GC for the corner */
white_gc = gdk_gc_new(dialog->window);
gdk_gc_set_foreground(white_gc, &white_color);
TITLE_STYLE(dialog);
footer_label = gtk_label_new(NULL);
PAGE_STYLE(footer_label);
gtk_label_set_justify(GTK_LABEL(footer_label), GTK_JUSTIFY_RIGHT);
gtk_box_pack_start(GTK_BOX(action_area), footer_label, FALSE, FALSE, 8);
gtk_widget_show(footer_label);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), vbox);
ebox = gtk_event_box_new();
TITLE_STYLE(ebox);
gtk_widget_set_events(ebox, GDK_EXPOSURE_MASK);
gtk_widget_set_size_request(ebox, WILBER_WIDTH + 16, -1);
gtk_box_pack_start(GTK_BOX(vbox), ebox, FALSE, FALSE, 0);
gtk_widget_show(ebox);
hbox = gtk_hbox_new(FALSE, 8);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
gtk_container_add(GTK_CONTAINER(ebox), hbox);
gtk_widget_show(hbox);
title_pixmap = create_pixmap(dialog,gabedit_xpm);
gtk_box_pack_start(GTK_BOX(hbox), title_pixmap, FALSE, FALSE, 8);
gtk_widget_show(title_pixmap);
title_label = gtk_label_new(NULL);
TITLE_STYLE(title_label);
gtk_label_set_justify(GTK_LABEL(title_label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(hbox), title_label, FALSE, FALSE, 0);
gtk_widget_show(title_label);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
ebox = gtk_event_box_new();
TITLE_STYLE(ebox);
gtk_widget_set_size_request(ebox, 16, -1);
gtk_box_pack_start(GTK_BOX(hbox), ebox, FALSE, FALSE, 0);
gtk_widget_show(ebox);
ebox = gtk_event_box_new();
PAGE_STYLE(ebox);
gtk_box_pack_start(GTK_BOX(hbox), ebox, TRUE, TRUE, 0);
gtk_widget_show(ebox);
table = gtk_table_new(3, 3, FALSE);
gtk_table_set_col_spacing(GTK_TABLE(table), 1, 8);
gtk_container_add(GTK_CONTAINER(ebox), table);
gtk_widget_show(table);
darea = gtk_drawing_area_new();
TITLE_STYLE(darea);
gtk_widget_set_size_request(GTK_WIDGET(darea), 16, 16);
g_signal_connect_after(G_OBJECT(darea), "expose_event",
(GCallback)user_install_corner_expose,
(gpointer)GTK_CORNER_TOP_LEFT);
gtk_table_attach(GTK_TABLE(table), darea, 0,1, 0,1,
GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show(darea);
darea = gtk_drawing_area_new();
TITLE_STYLE(darea);
gtk_widget_set_size_request(GTK_WIDGET(darea), 16, 16);
g_signal_connect_after(G_OBJECT(darea), "expose_event",
(GCallback)user_install_corner_expose,
(gpointer)GTK_CORNER_BOTTOM_LEFT);
gtk_table_attach(GTK_TABLE(table), darea, 0,1, 2,3,
GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show(darea);
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), notebook, 1,2, 1,2);
gtk_widget_show(notebook);
gtk_widget_show(vbox);
/* Page 1 */
temp = g_strdup_printf("Welcome to The GABEDIT %s User Installation",Version_S);
g_free(Version_S);
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
temp,
_("Click \"Continue\" to enter the GABEDIT user installation."));
add_label(GTK_BOX(page),
_(
"Gabedit is a Graphical User Interface to FireFly, Gamess-US, Gaussian, Molcas, Molpro, \nMopac, MPQC , NWChem, Orca, Psicode and Q-Chem\n"
"computational chemistry packages.\n"
"It can display a variety of calculation results including support for most major molecular file formats.\n"
"The advanced 'Molecule Builder' allows to rapidly sketch in molecules and examine them in 3D\n"
"Graphics can be exported to various formats, including animations\n"
"\n"
"Gabedit can creates input file for the computational chemistry packages(CCP) cited above.\n"
"Gabedit can graphically display a variety of the CCP calculation results\n"
"Gabedit can display UV-Vis, IR and Raman computed spectra.\n"
"Gabedit can generate a povray file for geometry, surfaces, contours, planes colorcoded.\n"
"Gabedit can save picture in BMP, JPEG, PNG, PPM, PDF and PS format.\n"
"It can generate automatically a series of pictures for animation(vibration, geometry convergence, ....).\n"
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show(sep);
add_label(GTK_BOX(page),
_(
"Copyright (c) 2002-2013 Abdul-Rahman Allouche.\n"
"All rights reserved.\n"
"\nGabedit is free.\n"
)
);
/* Page 2 */
{
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *notebook2;
GtkWidget *page2;
GtkWidget *label;
GtkTreeIter main_node;
GtkTreeIter sub_node;
gchar *str;
GtkTreeStore *store;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget* treeView;
GtkTreeSelection *select;
gint i;
gchar *node[1];
set_pixbuf();
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Personal GABEDIT Directory"),
_(
"Click \"Continue\" to create "
"your personal GABEDIT directory.")
);
hbox = gtk_hbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(page), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
store = gtk_tree_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
model = GTK_TREE_MODEL (store);
treeView = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeView), FALSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeView), FALSE);
PAGE_STYLE(treeView);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, " ");
gtk_tree_view_column_set_reorderable(column, FALSE);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", LIST_PIXBUF);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (column, renderer, "text", LIST_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), column);
gtk_box_pack_start(GTK_BOX(hbox), treeView, FALSE, FALSE, 0);
gtk_widget_show(treeView);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show(vbox);
str = g_strdup_printf(_("For a proper GABEDIT installation, a subdirectory named\n"
"%s needs to be created."), gabedit_directory());
add_label(GTK_BOX(vbox), str);
g_free(str);
add_label(GTK_BOX(vbox),
_(
"This subdirectory will contain a number of important files.\n"
"Click on one of the files or subdirectories in the tree\n"
"to get more information about the selected item."
)
);
notebook2 = gtk_notebook_new();
gtk_container_set_border_width(GTK_CONTAINER(notebook2), 8);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook2), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook2), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), notebook2, TRUE, TRUE, 0);
gtk_widget_show(notebook2);
/* empty page */
page2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(page2);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook2), page2, NULL);
node[0] = (gchar *)gabedit_directory();
gtk_tree_store_append(store, &main_node, NULL);
gtk_tree_store_set (store, &main_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &main_node, LIST_PIXBUF, bookPixbuf, -1);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeView));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (user_install_treeview_select_row), notebook2);
for (i = 0; i < num_tree_items; i++)
{
node[0] = tree_items[i].text;
if (tree_items[i].directory)
{
gtk_tree_store_append(store, &sub_node, &main_node);
gtk_tree_store_set (store, &sub_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &sub_node, LIST_PIXBUF, bookPixbuf, -1);
} else
{
gtk_tree_store_append(store, &sub_node, &main_node);
gtk_tree_store_set (store, &sub_node, LIST_NAME, node[0], -1);
gtk_tree_store_set (store, &sub_node, LIST_PIXBUF, pagePixbuf, -1);
}
page2 = gtk_vbox_new(FALSE, 0);
label = gtk_label_new(tree_items[i].description);
PAGE_STYLE(label);
PAGE_STYLE(label);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(page2), label, TRUE, TRUE, 0);
gtk_widget_show(label);
gtk_widget_show(page2);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook2), page2, NULL);
}
{
GtkTreePath *path = gtk_tree_path_new_from_string ("0");
gtk_tree_view_expand_to_path(GTK_TREE_VIEW(treeView), path);
gtk_tree_path_free(path);
}
}
/* Page 3 */
page = log_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Creation of Directories"),
NULL);
/* Page 4 */
page = prop_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Atoms Properties"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(page),_("Setting for atoms properties."));
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show(sep);
/* Page 5 */
page = commands_network_page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Commands/Network"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(commands_network_page),
_(
"To execute FireFly, Gamess-US, Gaussian, Molcas, Molpro, \nMopac, MPQC, NWChem, Orca, Psicode and Q-Chem program, "
"GABEDIT needs to know commands system.\n"
"GABEDIT needs to know network protocols.\n"
"You can change them after installation (Settings/Preferences)."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 6 */
page = fontscolors_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Fonts/Colors setting"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(fontscolors_page),
_(
"Setting for Text Font and Text Colors, "
"GABEDIT needs to know the defaults Fonts/Colors for Data and Result editors."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 7 */
page = colorsurfaces_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT Color Surfaces setting"),
_("Click \"Continue\" to accept the settings above."));
add_label(GTK_BOX(colorsurfaces_page),
_("Setting for color surfaces, "
"GABEDIT needs to know the defaults Color for surfaces(density,Orbitals,....)."
)
);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(page), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
/* Page 8 */
page = molpro_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of molpro basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(molpro_basis_page),
_(
"If the libmol program (delivered with molpro) is not installed on your local host,\n"
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by molpro.\n"
"Please note that this file contains the list of basis supported by molpro2002.6."
)
);
/* Page 9 */
page = molcas_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of molcas basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(molcas_basis_page),
_(
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by molcas.\n"
"Please note that this file contains the list of basis supported by Molcas7."
)
);
/* Page 10 */
page = mpqc_basis_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of mpqc basis list file"),
_("Click \"Continue\" for next page."));
add_label(GTK_BOX(mpqc_basis_page),
_(
"GABEDIT uses this file for get the list of basis(only the names of basis)supported by MPQC.\n"
"Please note that this file contains the list of basis supported by MPQC2.2.2."
)
);
/* Page 11 */
page = mm_file_page =
user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("GABEDIT creation of Molecular Mechanics file"),
_("Click \"Continue\" to start GABEDIT."));
add_label(GTK_BOX(mm_file_page),
_("Gabedit use this file for load molecular mechanics parameters "));
/* EEK page */
page = user_install_notebook_append_page(GTK_NOTEBOOK(notebook),
_("Aborting Installation..."),
NULL);
user_install_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
create_buttons_dialog(dialog,callback);
gtk_widget_show_all(dialog);
}
GtkWidget *
gnome_prefs_window_new (const gchar *logo_name)
{
GnomePrefsWindow *gpw = NULL;
GtkTreeSelection *selection = NULL;
GtkCellRenderer *cell = NULL;
GtkTreeStore *model = NULL;
GtkTreeViewColumn *column = NULL;
GtkWidget *window = NULL;
GtkWidget *event_box = NULL;
GtkWidget *hbox = NULL;
GtkWidget *vbox = NULL;
GtkWidget *frame = NULL;
GtkWidget *pixmap = NULL;
GtkWidget *hsep = NULL;
GdkColor cwhite;
PangoAttrList *attrs = NULL;
PangoAttribute *attr = NULL;
/* Box inside the prefs window */
GtkWidget *dialog_vbox = NULL;
/* Build the window */
window = gtk_dialog_new ();
gpw = (GnomePrefsWindow *) g_malloc (sizeof (GnomePrefsWindow));
gpw->last_page = 1;
g_object_set_data_full (G_OBJECT (window), "gpw", (gpointer) gpw, g_free);
gtk_dialog_add_button (GTK_DIALOG (window), GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL);
/* The sections */
gpw->notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (gpw->notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (gpw->notebook), FALSE);
pixmap = gtk_image_new_from_file (logo_name);
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box),
GTK_WIDGET (pixmap));
cwhite.red = 0xff * 0x100;
cwhite.green = 0xff * 0x100;
cwhite.blue = 0xff * 0x100;
gdk_colormap_alloc_color(gdk_colormap_get_system (), &cwhite, FALSE, TRUE);
gtk_widget_modify_bg (GTK_WIDGET (event_box),
GTK_STATE_NORMAL, &cwhite);
gtk_notebook_prepend_page (GTK_NOTEBOOK (gpw->notebook), event_box, NULL);
/* The sections */
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (window));
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_container_add (GTK_CONTAINER (dialog_vbox), hbox);
/* Build the TreeView on the left */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
model = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_INT);
gpw->sections_tree_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (gpw->sections_tree_view),
GTK_TREE_MODEL (model));
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (gpw->sections_tree_view));
gtk_container_add (GTK_CONTAINER (frame), gpw->sections_tree_view);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gpw->sections_tree_view),
FALSE);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL, cell, "text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (gpw->sections_tree_view),
GTK_TREE_VIEW_COLUMN (column));
gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection),
GTK_SELECTION_BROWSE);
/* Some design stuff to put the notebook pages in it */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
gpw->section_label = gtk_label_new (NULL);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_misc_set_alignment (GTK_MISC (gpw->section_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (frame), gpw->section_label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
attrs = pango_attr_list_new ();
attr = pango_attr_scale_new (PANGO_SCALE_LARGE);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert (attrs, attr);
attr = pango_attr_weight_new (PANGO_WEIGHT_HEAVY);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert (attrs, attr);
gtk_label_set_attributes (GTK_LABEL (gpw->section_label), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (gpw->section_label);
hsep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), hsep, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gpw->notebook, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (dialog_vbox));
gtk_widget_show_all (GTK_WIDGET (gpw->sections_tree_view));
g_signal_connect (selection, "changed",
G_CALLBACK (tree_selection_changed_cb),
gpw);
return window;
}
gu_window_t *
gu_win_create(gtk_ui_t *gu, int all, prop_t *nav)
{
gu_window_t *gw = calloc(1, sizeof(gu_window_t));
LIST_INSERT_HEAD(&gu->gu_windows, gw, gw_link);
gw->gw_gu = gu;
gw->gw_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_events(gw->gw_window, GDK_FOCUS_CHANGE_MASK);
gtk_window_set_title(GTK_WINDOW(gw->gw_window), "Showtime");
gtk_window_set_default_size(GTK_WINDOW(gw->gw_window), 640, 400);
g_signal_connect(G_OBJECT(gw->gw_window), "delete_event",
G_CALLBACK(gw_close), gw);
g_signal_connect(G_OBJECT(gw->gw_window), "focus-in-event",
G_CALLBACK(gw_focused), gw);
gw->gw_vbox = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(gw->gw_window), gw->gw_vbox);
gtk_widget_show(gw->gw_vbox);
gw->gw_view_toolbar = 1;
if(all) {
gw->gw_view_playdeck = 1;
gw->gw_view_statusbar = 1;
}
/* Menubar */
gw->gw_menubar = gu_menubar_add(gw, gw->gw_vbox);
gtk_widget_show_all(gw->gw_menubar);
/* Notebook (that which contains tabs) */
gw->gw_notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(gw->gw_vbox),
gw->gw_notebook, TRUE, TRUE, 0);
gtk_notebook_set_show_border(GTK_NOTEBOOK(gw->gw_notebook), 0);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gw->gw_notebook), 0);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(gw->gw_notebook), 1);
gtk_widget_show(gw->gw_notebook);
g_signal_connect(G_OBJECT(gw->gw_notebook), "switch-page",
G_CALLBACK(tab_changed), gw);
/* Playback controls */
gw->gw_playdeck = gu_playdeck_add(gw, gw->gw_vbox);
if(gw->gw_view_playdeck)
gtk_widget_show(gw->gw_playdeck);
/* Statusbar */
gw->gw_statusbar = gu_statusbar_add(gw, gw->gw_vbox);
if(gw->gw_view_statusbar)
gtk_widget_show(gw->gw_statusbar);
g_signal_connect(G_OBJECT(gw->gw_window), "key-press-event",
G_CALLBACK(window_key_pressed), gw);
g_signal_connect(G_OBJECT(gw->gw_window), "window-state-event",
G_CALLBACK(window_state_event), gw);
gu_tab_create(gw, 1, nav);
gtk_widget_show(gw->gw_window);
return gw;
}
static void
gdict_sidebar_init (GdictSidebar *sidebar)
{
GdictSidebarPrivate *priv;
GtkWidget *hbox;
GtkWidget *select_hbox;
GtkWidget *select_button;
GtkWidget *close_button;
GtkWidget *arrow;
sidebar->priv = priv = GDICT_SIDEBAR_GET_PRIVATE (sidebar);
/* we store all the pages inside the list, but we keep
* a pointer inside the hash table for faster look up
* times; what's inside the table will be destroyed with
* the list, so there's no need to supply the destroy
* functions for keys and values.
*/
priv->pages = NULL;
priv->pages_by_id = g_hash_table_new (g_str_hash, g_str_equal);
/* top option menu */
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (sidebar), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
priv->hbox = hbox;
select_button = gtk_toggle_button_new ();
gtk_button_set_relief (GTK_BUTTON (select_button), GTK_RELIEF_NONE);
g_signal_connect (select_button, "button-press-event",
G_CALLBACK (gdict_sidebar_select_button_press_cb),
sidebar);
g_signal_connect (select_button, "key-press-event",
G_CALLBACK (gdict_sidebar_select_key_press_cb),
sidebar);
priv->select_button = select_button;
select_hbox = gtk_hbox_new (FALSE, 0);
priv->label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (select_hbox), priv->label, FALSE, FALSE, 0);
gtk_widget_show (priv->label);
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
gtk_box_pack_end (GTK_BOX (select_hbox), arrow, FALSE, FALSE, 0);
gtk_widget_show (arrow);
gtk_container_add (GTK_CONTAINER (select_button), select_hbox);
gtk_widget_show (select_hbox);
gtk_box_pack_start (GTK_BOX (hbox), select_button, TRUE, TRUE, 0);
gtk_widget_show (select_button);
close_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
gtk_button_set_image (GTK_BUTTON (close_button),
gtk_image_new_from_stock (GTK_STOCK_CLOSE,
GTK_ICON_SIZE_SMALL_TOOLBAR));
g_signal_connect (close_button, "clicked",
G_CALLBACK (gdict_sidebar_close_clicked_cb),
sidebar);
gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
gtk_widget_show (close_button);
priv->close_button = close_button;
sidebar->priv->menu = gtk_menu_new ();
g_signal_connect (sidebar->priv->menu, "deactivate",
G_CALLBACK (gdict_sidebar_menu_deactivate_cb),
sidebar);
gtk_menu_attach_to_widget (GTK_MENU (sidebar->priv->menu),
GTK_WIDGET (sidebar),
gdict_sidebar_menu_detach_cb);
gtk_widget_show (sidebar->priv->menu);
sidebar->priv->notebook = gtk_notebook_new ();
gtk_notebook_set_show_border (GTK_NOTEBOOK (sidebar->priv->notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (sidebar->priv->notebook), FALSE);
gtk_box_pack_start (GTK_BOX (sidebar), sidebar->priv->notebook, TRUE, TRUE, 6);
gtk_widget_show (sidebar->priv->notebook);
}
static gboolean
create_app (void)
{
GtkWidget *menubar;
GtkWidget *gridframe;
GtkWidget *grid;
GtkWidget *vpaned;
GtkUIManager *ui_manager;
app = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (app), _(APPNAME_LONG));
gtk_window_set_default_size (GTK_WINDOW (app), DEFAULT_WIDTH, DEFAULT_HEIGHT);
//games_conf_add_window (GTK_WINDOW (app), NULL);
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 (G_OBJECT (app), "delete_event",
G_CALLBACK (on_game_exit), NULL);
gtk_window_set_default_icon_name ("gnect");
statusbar = gtk_statusbar_new ();
ui_manager = gtk_ui_manager_new ();
games_stock_prepare_for_statusbar_tooltips (ui_manager, statusbar);
create_game_menus (ui_manager);
menubar = gtk_ui_manager_get_widget (ui_manager, "/MainMenu");
vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_widget_set_hexpand (vpaned, TRUE);
gtk_widget_set_vexpand (vpaned, TRUE);
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
gridframe = games_grid_frame_new (7, 7);
gtk_paned_pack1 (GTK_PANED (vpaned), gridframe, TRUE, FALSE);
gtk_container_add (GTK_CONTAINER (grid), menubar);
gtk_container_add (GTK_CONTAINER (grid), vpaned);
gtk_container_add (GTK_CONTAINER (grid), statusbar);
gtk_container_add (GTK_CONTAINER (app), notebook);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), grid, NULL);
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), MAIN_PAGE);
drawarea = gtk_drawing_area_new ();
/* set a min size to avoid pathological behavior of gtk when scaling down */
gtk_widget_set_size_request (drawarea, 200, 200);
gtk_container_add (GTK_CONTAINER (gridframe), drawarea);
gtk_widget_set_events (drawarea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
g_signal_connect (G_OBJECT (drawarea), "configure_event",
G_CALLBACK (on_drawarea_resize), NULL);
g_signal_connect (G_OBJECT (drawarea), "draw",
G_CALLBACK (on_drawarea_draw), NULL);
g_signal_connect (G_OBJECT (drawarea), "button_press_event",
G_CALLBACK (on_button_press), NULL);
g_signal_connect (G_OBJECT (app), "key_press_event",
G_CALLBACK (on_key_press), NULL);
/* We do our own double-buffering. */
gtk_widget_set_double_buffered (GTK_WIDGET (drawarea), FALSE);
gtk_action_set_sensitive (hint_action, FALSE);
gtk_action_set_sensitive (undo_action, FALSE);
gtk_widget_show_all (app);
gfx_refresh_pixmaps ();
gfx_draw_all ();
scorebox_update (); /* update visible player descriptions */
prompt_player ();
return TRUE;
}
GtkWidget * yank_app_new(EYank *yank)
{
yank_preferences *prefs;
static GtkTargetEntry drop_types[] =
{
{ "text/uri-list", 0, 1 },
};
static gint n_drop_types = sizeof (drop_types)/sizeof (drop_types [0]);
gchar *treetitle[] =
{
_("NoteTree"),
NULL
};
gchar *todotitles[] =
{
_("Deadline"),
_("Priority"),
_("Complete"),
_("Title"),
NULL
};
GtkWidget *app;
GtkWidget *scrolledwindow1;
GtkWidget *scrolledwindow2;
GtkWidget *scrolledwindow3;
GtkWidget *hbox;
GtkWidget *hbox3;
GtkWidget *vbox;
GtkWidget *label;
GdkFont *font;
GtkObject *prio_adjust;
/* gint got_crash; */
GtkWidget *b_toggle_ext_flags;
GtkWidget *hbox_ext_flags;
GtkWidget *hpaned;
hpaned = app = yank->priv->hpaned;
yank_main_app(app);
sp->edit_tree = NULL;
sp->title_entry =NULL;
sp->todo_check =NULL;
sp->prio_entry =NULL;
sp->de_deadline =NULL;
sp->ad_complete =NULL;
sp->tlabel_created =NULL;
sp->tlabel_changed =NULL;
sp->label_changes =NULL;
sp->tlabel_expire =NULL;
sp->note_id_entry =NULL;
sp->text_entry =NULL;
sp->note_tree =NULL;
sp->b_ok =NULL;
sp->b_apply =NULL;
sp->b_cancel =NULL;
sp->todolist =NULL;
sp->notebook =NULL;
sp->status =NULL;
sp->prio_date_box =NULL;
sp->edit_tree=NULL;
yank_root_win(GTK_WINDOW(app));
/*
* main tree
*/
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
/* gtk_widget_show will be called later */
/* gtk_container_add(GTK_CONTAINER(hpaned), scrolledwindow1); */
e_paned_add1(E_PANED(hpaned), scrolledwindow1);
sp->note_tree = gtk_ctree_new_with_titles(1, 0, treetitle);
gtk_widget_show(sp->note_tree);
gtk_container_add(GTK_CONTAINER(scrolledwindow1), sp->note_tree);
gtk_clist_set_column_width(GTK_CLIST(sp->note_tree), 0, 80);
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->note_tree), 0, TRUE);
gtk_clist_set_row_height(GTK_CLIST(sp->note_tree), 19);
gtk_clist_set_selection_mode(GTK_CLIST(sp->note_tree), GTK_SELECTION_EXTENDED);
gtk_clist_set_reorderable(GTK_CLIST(sp->note_tree), TRUE);
gtk_clist_set_use_drag_icons(GTK_CLIST(sp->note_tree), TRUE);
gtk_clist_column_titles_show(GTK_CLIST(sp->note_tree));
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_select_row",
GTK_SIGNAL_FUNC (note_tree_row_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_unselect_row",
GTK_SIGNAL_FUNC (note_tree_row_unselected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "click_column",
GTK_SIGNAL_FUNC (cb_note_tree_col_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received",
GTK_SIGNAL_FUNC(cb_note_tree_reordered), NULL);
/*
* FIXME:
* dnd on the note-tree disables reordering of notes by dnd
*/
/* gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received", */
/* GTK_SIGNAL_FUNC(cb_note_tree_drop), NULL); */
/* gtk_drag_dest_set(sp->note_tree, GTK_DEST_DEFAULT_MOTION | */
/* GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, */
/* drop_types, n_drop_types, GDK_ACTION_COPY); */
sp->notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(sp->notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(sp->notebook), FALSE);
gtk_widget_show(sp->notebook);
/* gtk_container_add(GTK_CONTAINER(hpaned), sp->notebook); */
e_paned_add2(E_PANED(hpaned), sp->notebook);
/*
* todo-list
*/
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolledwindow2);
gtk_container_add(GTK_CONTAINER(sp->notebook), scrolledwindow2);
sp->todolist = gtk_clist_new_with_titles(4, todotitles);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "select_row",
GTK_SIGNAL_FUNC (cb_todo_row_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "click_column",
GTK_SIGNAL_FUNC (cb_todo_col_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "drag_data_received",
GTK_SIGNAL_FUNC(cb_todo_list_drop), NULL);
gtk_drag_dest_set(sp->todolist, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
drop_types, n_drop_types, GDK_ACTION_COPY);
gtk_widget_show(sp->todolist);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), sp->todolist);
gtk_clist_column_titles_show(GTK_CLIST(sp->todolist));
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 0 , TRUE);
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 3 , TRUE);
gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 1,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 2,
GTK_JUSTIFY_RIGHT);
/*
* text/ data
*/
vbox = gtk_vbox_new(FALSE, 3);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER (sp->notebook), vbox);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
sp->prio_date_box = gtk_vbox_new(FALSE, 3);
gtk_widget_show(sp->prio_date_box);
gtk_box_pack_start(GTK_BOX(vbox), sp->prio_date_box, FALSE, FALSE, 0);
hbox_ext_flags = gui_ext_flags();
gtk_box_pack_start(GTK_BOX(vbox), hbox_ext_flags, FALSE, FALSE, 3);
label = gtk_label_new(_("Title:"));
font = gtk_widget_get_style(label)->font;
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
sp->title_entry = gtk_entry_new();
gtk_widget_set_usize(sp->title_entry, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->title_entry);
gtk_box_pack_start(GTK_BOX(hbox), sp->title_entry, TRUE, TRUE, 5);
sp->todo_check = gtk_check_button_new_with_label(_("Done"));
gtk_widget_set_usize(sp->todo_check, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->todo_check);
gtk_box_pack_start(GTK_BOX(hbox), sp->todo_check, FALSE, FALSE, 5);
/*
* button for extra flags& data
*/
b_toggle_ext_flags = gtk_button_new();
{
GtkWidget *p_up;
GtkWidget *p_down;
GtkWidget *box;
box = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(b_toggle_ext_flags), box);
gtk_widget_show(box);
p_up = gnome_stock_pixmap_widget_at_size(
GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_UP, 12, 14);
p_down = gnome_stock_pixmap_widget_at_size(
GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_DOWN, 12, 14);
gtk_widget_hide(p_up);
gtk_widget_show(p_down);
gtk_container_add(GTK_CONTAINER(box), p_up);
gtk_container_add(GTK_CONTAINER(box), p_down);
gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "up", p_up);
gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "down", p_down);
}
gtk_widget_show(b_toggle_ext_flags);
gtk_box_pack_start(GTK_BOX(hbox), b_toggle_ext_flags, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(b_toggle_ext_flags), "clicked",
GTK_SIGNAL_FUNC(cb_toggle_ext_flags), hbox_ext_flags);
/*
* deadline/ prio/ complete
*/
{
GtkWidget *prio_hbox1;
GtkWidget *prio_hbox2;
GtkWidget *sc_complete;
prio_hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(prio_hbox1);
gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox1, FALSE, FALSE,
0);
prio_hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(prio_hbox2);
gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox2, FALSE, FALSE,
0);
label = gtk_label_new(_("Deadline:"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5);
sp->de_deadline = gnome_date_edit_new(0, 1, 1);
gnome_date_edit_set_popup_range(GNOME_DATE_EDIT(sp->de_deadline), 0, 23);
gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->date_entry,
FALSE);
gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->time_entry,
FALSE);
gtk_widget_show(sp->de_deadline);
gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->de_deadline, FALSE, FALSE, 0);
label = gtk_label_new(_("Priority:"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5);
prio_adjust = gtk_adjustment_new(0, 0, 9999, 1, 10, 10);
sp->prio_entry = gtk_spin_button_new(GTK_ADJUSTMENT(prio_adjust), 1, 0);
/* NOTE: this is note 100% ok */
gtk_widget_set_usize(GTK_WIDGET(sp->prio_entry),
gdk_string_width(font, "999999") + 10,
gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->prio_entry);
gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->prio_entry, FALSE, FALSE, 0);
label = gtk_label_new(_("Complete:"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5);
sp->ad_complete = gtk_adjustment_new(0, 0, 101, 1, 1, 1);
sc_complete = gtk_hscale_new(GTK_ADJUSTMENT(sp->ad_complete));
gtk_scale_set_digits(GTK_SCALE(sc_complete), 0);
gtk_scale_set_value_pos(GTK_SCALE(sc_complete), GTK_POS_LEFT);
gtk_widget_show(sc_complete);
gtk_box_pack_start(GTK_BOX(prio_hbox2), sc_complete, TRUE, TRUE, 5);
label = gtk_label_new(_("%"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5);
}
/*
* additional note data
*/
sp->note_id_entry = gtk_entry_new();
/* gtk_widget_show(sp->note_id_entry); */
gtk_widget_hide(sp->note_id_entry);
gtk_box_pack_start(GTK_BOX(hbox), sp->note_id_entry, FALSE, FALSE, 5);
/*
* note text
*/
scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolledwindow3);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow3, TRUE, TRUE, 0);
sp->text_entry = gtk_text_new(NULL, NULL);
gtk_text_set_editable(GTK_TEXT(sp->text_entry), TRUE);
gtk_widget_show(sp->text_entry);
gtk_container_add(GTK_CONTAINER(scrolledwindow3), sp->text_entry);
/* text dnd */
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "drag_data_received",
GTK_SIGNAL_FUNC(cb_text_entry_drop), NULL);
gtk_drag_dest_set(sp->text_entry, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
drop_types, n_drop_types, GDK_ACTION_COPY);
hbox3 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox3);
gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 3);
sp->b_ok = gnome_stock_button(GNOME_STOCK_BUTTON_OK);
gtk_widget_show(sp->b_ok);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_ok, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_ok), "clicked",
GTK_SIGNAL_FUNC(cb_b_ok), NULL);
sp->b_apply = gnome_stock_button(GNOME_STOCK_BUTTON_APPLY);
gtk_widget_show(sp->b_apply);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_apply, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_apply), "clicked",
GTK_SIGNAL_FUNC(cb_b_apply), NULL);
sp->b_cancel = gnome_stock_button(GNOME_STOCK_BUTTON_CANCEL);
gtk_widget_show(sp->b_cancel);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_cancel, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_cancel), "clicked",
GTK_SIGNAL_FUNC(cb_b_cancel), NULL);
/*
* a bit suboptimal
*/
gtk_signal_connect(GTK_OBJECT(sp->title_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "date-changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "time-changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->tlabel_expire), "time_changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->prio_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed",
GTK_SIGNAL_FUNC(cb_complete_updates_done), sp->todo_check);
gtk_signal_connect(GTK_OBJECT(sp->todo_check), "toggled",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
/*
* keyboard-control
*/
gtk_signal_connect(GTK_OBJECT(sp->title_entry), "activate",
GTK_SIGNAL_FUNC(cb_finished_note), NULL);
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "activate",
GTK_SIGNAL_FUNC(cb_finished_note), NULL);
/*
* create pixmaps
*/
pix_text_xpm = gnome_pixmap_new_from_xpm_d(text_xpm);
gtk_widget_show(pix_text_xpm);
pix_box_xpm = gnome_pixmap_new_from_xpm_d(box_xpm);
gtk_widget_show(pix_box_xpm);
pix_box2_xpm = gnome_pixmap_new_from_xpm_d(box2_xpm);
gtk_widget_show(pix_box2_xpm);
pix_circle_xpm = gnome_pixmap_new_from_xpm_d(circle_xpm);
gtk_widget_show(pix_circle_xpm);
pix_circle2_xpm = gnome_pixmap_new_from_xpm_d(circle2_xpm);
gtk_widget_show(pix_circle2_xpm);
/*
* menus
*/
/* gnome_app_set_contents(GNOME_APP(app), hpaned); */
/* sp->status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_USER); */
/* gnome_app_set_statusbar(GNOME_APP(app), sp->status); */
/* yank_install_menus_and_toolbar(app); */
yank_tree_item_context_menu(sp->note_tree);
yank_todo_item_context_menu(sp->todolist);
yank_text_item_context_menu(sp->title_entry);
yank_text_item_context_menu(sp->text_entry);
/* gtk_signal_connect(GTK_OBJECT(app), "delete_event", */
/* GTK_SIGNAL_FUNC(cb_delete_event), NULL); */
/*
* initialize preferences
* also preloads plugins
*/
load_preferences();
prefs = get_preferences();
gtk_text_set_word_wrap(GTK_TEXT(sp->text_entry), prefs->wordwrap);
gtk_text_set_line_wrap(GTK_TEXT(sp->text_entry), prefs->linewrap);
/* if (prefs->yank_width * prefs->yank_height) */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), prefs->yank_width, */
/* prefs->yank_height); */
/* } */
/* else */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), 600, 400); */
/* } */
if (prefs->use_custom_font)
{
if (prefs->note_font)
{
set_note_font_str(prefs->note_font);
}
if (prefs->note_tree_font)
{
set_note_tree_font_str(prefs->note_tree_font);
}
if (prefs->todolist_font)
{
set_todolist_font_str(prefs->todolist_font);
}
}
else
{
set_default_font();
}
/*
* parse geometry if given
*/
/* if (geometry != NULL) */
/* { */
/* gint x, y, w, h; */
/* if (gnome_parse_geometry(geometry, &x, &y, &w, &h )) */
/* { */
/* if (x != -1) */
/* { */
/* gtk_widget_set_uposition(app, x, y); */
/* } */
/* */
/* if (w != -1) */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), w, h); */
/* } */
/* } */
/* else */
/* { */
/* g_error(_("Could not parse geometry string `%s'"), geometry); */
/* } */
/* } */
/* */
/* if (prefs->note_tree_width) */
/* { */
/* gtk_widget_set_usize(scrolledwindow1, prefs->note_tree_width, -1); */
/* } */
/* else */
/* { */
/* gtk_widget_set_usize(scrolledwindow1, 200, -1); */
/* } */
/* gtk_widget_show(scrolledwindow1); */
/*
* try to read files from killed sessions
*/
/* got_crash = get_crash_file(); */
/*
* load file from the command-line
*/
/* if (file != NULL && ! got_crash) */
/* { */
/* load_notes_from_cli((gchar *)file, GTK_CTREE(sp->note_tree), NULL); */
/* } */
/*
* read default file
*/
/* if (file == NULL && ! got_crash) */
/* { */
/* get_def_file(); */
/* } */
/*
* register some signal-handlers
*/
/* if (signal(SIGTERM, handle_sigterm) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGTERM"); */
/* } */
/* if (signal(SIGCHLD, handle_sigchild) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGCHILD"); */
/* } */
/* if (signal(SIGPIPE, handle_sigpipe) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGPIPE"); */
/* } */
/*
* init autosave
*/
/* if (prefs->auto_save_minutes) */
/* { */
/* autosave_notes(NULL); */
/* } */
return (hpaned);
}
void termit_toggle_tabbar()
{
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(termit.notebook), configs.hide_tabbar);
configs.hide_tabbar = !configs.hide_tabbar;
}
static void
git_repository_selector_init (GitRepositorySelector *self)
{
GtkWidget *button_hbox;
GtkWidget *remote_hbox;
GtkWidget *label;
self->priv = g_new0 (GitRepositorySelectorPriv, 1);
/* Mode selector buttons. Allows the user to use a selected remote or
* enter a URL. */
button_hbox = gtk_hbox_new (TRUE, 0);
/* Remote toggle button */
self->priv->remote_toggle = gtk_radio_button_new_with_label (NULL,
_("Remote"));
g_object_set (G_OBJECT (self->priv->remote_toggle), "draw-indicator", FALSE,
NULL);
gtk_box_pack_start (GTK_BOX (button_hbox), self->priv->remote_toggle, TRUE,
TRUE, 0);
g_object_set_data (G_OBJECT (self->priv->remote_toggle), "mode",
GINT_TO_POINTER (GIT_REPOSITORY_SELECTOR_REMOTE));
g_signal_connect (G_OBJECT (self->priv->remote_toggle), "toggled",
G_CALLBACK (on_mode_button_toggled),
self);
/* URL toggle button */
self->priv->url_toggle = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (self->priv->remote_toggle)),
_("URL"));
g_object_set (G_OBJECT (self->priv->url_toggle), "draw-indicator", FALSE,
NULL);
gtk_box_pack_start (GTK_BOX (button_hbox), self->priv->url_toggle, TRUE,
TRUE, 0);
g_object_set_data (G_OBJECT (self->priv->url_toggle), "mode",
GINT_TO_POINTER (GIT_REPOSITORY_SELECTOR_URL));
g_signal_connect (G_OBJECT (self->priv->url_toggle), "toggled",
G_CALLBACK (on_mode_button_toggled),
self);
gtk_box_pack_start (GTK_BOX (self), button_hbox, FALSE, FALSE, 0);
/* Selected remote label */
remote_hbox = gtk_hbox_new (FALSE, 2);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), _("<b>Selected Remote:</b>"));
gtk_box_pack_start (GTK_BOX (remote_hbox), label, FALSE, FALSE, 0);
self->priv->selected_remote_label = gtk_label_new (NULL);
g_object_set (G_OBJECT (self->priv->selected_remote_label), "xalign",
0.0f, NULL);
gtk_box_pack_start (GTK_BOX (remote_hbox),
self->priv->selected_remote_label, TRUE, TRUE, 0);
/* URL entry */
self->priv->url_entry = gtk_entry_new ();
/* Notebook */
self->priv->notebook = gtk_notebook_new ();
gtk_notebook_set_show_border (GTK_NOTEBOOK (self->priv->notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->priv->notebook), FALSE);
gtk_notebook_append_page (GTK_NOTEBOOK (self->priv->notebook), remote_hbox,
NULL);
gtk_notebook_append_page (GTK_NOTEBOOK (self->priv->notebook),
self->priv->url_entry, NULL);
gtk_box_pack_start (GTK_BOX (self), self->priv->notebook, TRUE, TRUE, 0);
/* Set the selected repository label to a resonable default. */
git_repository_selector_set_remote (self, NULL);
/* Allow focusing */
gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE);
gtk_widget_show_all (GTK_WIDGET (self));
}
void mainwindow_create_tab(void)
{
GtkWidget* tmp_term = build_term();
GtkVScrollbar *sbar= NULL;
GtkHBox *tmp_box = GTK_HBOX(gtk_hbox_new(FALSE, 0));
if(conf_get_scrollbar() == -1)
gtk_box_pack_start(GTK_BOX(tmp_box), tmp_term, TRUE, TRUE, 0);
else if(conf_get_scrollbar() == POS_LEFT)
{
sbar = GTK_VSCROLLBAR(gtk_vscrollbar_new(vte_terminal_get_adjustment(
VTE_TERMINAL(tmp_term))));
gtk_box_pack_start(GTK_BOX(tmp_box), GTK_WIDGET(sbar), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(tmp_box), GTK_WIDGET(tmp_term), TRUE, TRUE, 0);
}
else // (conf_get_scrollbar() == POS_RIGHT)
{
sbar = GTK_VSCROLLBAR(gtk_vscrollbar_new(vte_terminal_get_adjustment(
VTE_TERMINAL(tmp_term))));
gtk_box_pack_start(GTK_BOX(tmp_box), GTK_WIDGET(tmp_term), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(tmp_box), GTK_WIDGET(sbar), FALSE, FALSE, 0);
}
char buffer [100];
sprintf(buffer, "%s %d", conf_get_term_name(), activetab + 1);
GtkLabel* tmp_label = GTK_LABEL(gtk_label_new(buffer));
if(conf_get_opacity() < 100)
{
if(screen_is_composited)
{
vte_terminal_set_background_transparent(VTE_TERMINAL(tmp_term), FALSE);
vte_terminal_set_opacity(VTE_TERMINAL(tmp_term),
conf_get_opacity()/100 * 0xffff);
}
else
{
vte_terminal_set_background_saturation(VTE_TERMINAL(tmp_term),
1.0 - conf_get_opacity()/100);
if(conf_get_bg_image() == NULL)
vte_terminal_set_background_transparent(VTE_TERMINAL(tmp_term), TRUE);
}
}
if(conf_get_opacity() < 100 && screen_is_composited)
{
vte_terminal_set_background_transparent(VTE_TERMINAL(tmp_term), FALSE);
vte_terminal_set_opacity(VTE_TERMINAL(tmp_term),
conf_get_opacity()/100 * 0xffff);
}
g_signal_connect(G_OBJECT(tmp_term), "window-title-changed",
G_CALLBACK(mainwindow_window_title_changed), tmp_label);
tabcount++;
gtk_widget_show_all(GTK_WIDGET(tmp_box));
gtk_notebook_append_page(tabbar, GTK_WIDGET(tmp_box), GTK_WIDGET(tmp_label));
if(conf_get_tab_fill())
gtk_container_child_set(GTK_CONTAINER(tabbar), GTK_WIDGET(tmp_box),
"tab-expand", TRUE, "tab-fill", TRUE, NULL);
if(conf_get_show_tab() == TABS_ONE&& tabcount > 1)
gtk_notebook_set_show_tabs(tabbar, TRUE);
activetab = tabcount - 1;
gtk_notebook_set_current_page(tabbar, activetab);
if(conf_get_allow_reorder())
gtk_notebook_set_tab_reorderable(tabbar, GTK_WIDGET(tmp_box), TRUE);
guint i;
for(i = 0; i < uri_regex_count; ++i)
{
int tag = vte_terminal_match_add_gregex(VTE_TERMINAL(tmp_term), uri_regex[i], 0);
vte_terminal_match_set_cursor_type(VTE_TERMINAL(tmp_term), tag, GDK_HAND2);
}
if(tabcount > 1)
gtk_widget_set_sensitive(close_tab, TRUE);
}
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 *tag1 = gtk_label_new( "This is page one" );
GtkWidget *tag2 = gtk_label_new( "This is page TWO" );
GtkWidget *tag3 = gtk_label_new( "This is page THree" );
GtkWidget *tag4 = gtk_label_new( "This is page 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 *vpane = gtk_vpaned_new();
GtkWidget *hbox = gtk_hbox_new( TRUE, 10 );
GtkWidget *nvbox1 = gtk_vbox_new( TRUE, 5 );
GtkWidget *nvbox2 = gtk_vbox_new( TRUE, 5 );
GtkWidget *nvbox3 = gtk_vbox_new( TRUE, 5 );
GtkWidget *nvbox4 = gtk_vbox_new( TRUE, 5 );
GtkWidget *expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" );
gtk_container_add( GTK_CONTAINER( expander ), next );
gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_box_pack_start( GTK_BOX( nvbox1 ), tag1, FALSE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( nvbox1 ), expander, FALSE, FALSE, 5 );
expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" );
gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE );
next = gtk_button_new_with_label( "Next" );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_container_add( GTK_CONTAINER( expander ), next );
gtk_box_pack_start( GTK_BOX( nvbox2 ), tag2, FALSE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( nvbox2 ), expander, FALSE, FALSE, 5 );
expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" );
gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE );
next = gtk_button_new_with_label( "Next" );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_container_add( GTK_CONTAINER( expander ), next );
gtk_box_pack_start( GTK_BOX( nvbox3 ), tag3, FALSE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( nvbox3 ), expander, FALSE, FALSE, 5 );
expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" );
gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE );
next = gtk_button_new_with_label( "Next" );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_container_add( GTK_CONTAINER( expander ), next );
gtk_box_pack_start( GTK_BOX( nvbox4 ), tag4, FALSE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( nvbox4 ), expander, FALSE, FALSE, 5 );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox1, one );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox2, two );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox3, three );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox4, four );
gtk_notebook_set_tab_pos( GTK_NOTEBOOK( notebook ), GTK_POS_TOP );
gtk_notebook_set_show_tabs( GTK_NOTEBOOK( notebook ), TRUE );
g_signal_connect( G_OBJECT( prev ), "clicked", G_CALLBACK( prev_pressed ), (gpointer) notebook );
g_signal_connect( G_OBJECT( exit ), "clicked", G_CALLBACK( exit_pressed ), NULL );
gtk_box_pack_end( GTK_BOX( hbox ), exit, TRUE, FALSE, 5 );
gtk_box_pack_end( GTK_BOX( hbox ), prev, TRUE, FALSE, 5 );
gtk_paned_pack1( GTK_PANED( vpane ), notebook, TRUE, FALSE );
gtk_paned_pack2( GTK_PANED( vpane ), hbox, TRUE, FALSE );
g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( destroy ), NULL );
gtk_container_add( GTK_CONTAINER( window ), vpane );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
static void
source_viewer_constructed (GObject *object)
{
ESourceViewer *viewer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkWidget *container;
GtkWidget *paned;
GtkWidget *widget;
PangoAttribute *attr;
PangoAttrList *bold;
PangoFontDescription *desc;
GIcon *icon;
const gchar *title;
gchar *font_name;
gint page_num;
viewer = E_SOURCE_VIEWER (object);
/* Chain up to parent's constructed() method. */
G_OBJECT_CLASS (e_source_viewer_parent_class)->constructed (object);
bold = pango_attr_list_new ();
attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
pango_attr_list_insert (bold, attr);
title = _("Evolution Source Viewer");
gtk_window_set_title (GTK_WINDOW (viewer), title);
gtk_window_set_default_size (GTK_WINDOW (viewer), 800, 600);
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position (GTK_PANED (paned), 400);
gtk_container_add (GTK_CONTAINER (viewer), paned);
gtk_widget_show (paned);
/* Left panel */
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (
GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
gtk_paned_add1 (GTK_PANED (paned), widget);
gtk_widget_show (widget);
container = widget;
widget = gtk_tree_view_new_with_model (
GTK_TREE_MODEL (viewer->tree_store));
gtk_container_add (GTK_CONTAINER (container), widget);
viewer->tree_view = widget; /* do not reference */
gtk_widget_show (widget);
column = gtk_tree_view_column_new ();
/* Translators: The name that is displayed in the user interface */
gtk_tree_view_column_set_title (column, _("Display Name"));
gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_add_attribute (
column, renderer, "text", COLUMN_DISPLAY_NAME);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Flags"));
gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (
renderer,
"icon-name", "media-record",
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "visible", COLUMN_WRITABLE);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (
renderer,
"icon-name", "list-remove",
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "visible", COLUMN_REMOVABLE);
icon = source_view_new_remote_creatable_icon ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (
renderer,
"gicon", icon,
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "visible", COLUMN_REMOTE_CREATABLE);
g_object_unref (icon);
icon = source_view_new_remote_deletable_icon ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (
renderer,
"gicon", icon,
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "visible", COLUMN_REMOTE_DELETABLE);
g_object_unref (icon);
/* Append an empty pixbuf renderer to fill leftover space. */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Identity"));
gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (
column, renderer, "text", COLUMN_SOURCE_UID);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
/* Right panel */
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_paned_add2 (GTK_PANED (paned), widget);
gtk_widget_show (widget);
container = widget;
widget = gtk_notebook_new ();
gtk_widget_set_margin_top (widget, 3);
gtk_widget_set_margin_right (widget, 3);
gtk_widget_set_margin_bottom (widget, 3);
/* leave left margin at zero */
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (widget), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (widget), FALSE);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
viewer->top_panel = widget; /* do not reference */
gtk_widget_show (widget);
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (
GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
container = widget;
widget = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (widget), FALSE);
gtk_container_add (GTK_CONTAINER (container), widget);
viewer->text_view = widget; /* do not reference */
gtk_widget_show (widget);
font_name = source_viewer_get_monospace_font_name ();
desc = pango_font_description_from_string (font_name);
gtk_widget_override_font (widget, desc);
pango_font_description_free (desc);
g_free (font_name);
/* Top panel: Viewing */
container = viewer->top_panel;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
page_num = gtk_notebook_append_page (
GTK_NOTEBOOK (container), widget, NULL);
g_warn_if_fail (page_num == PAGE_VIEWING);
gtk_widget_show (widget);
container = widget;
widget = gtk_label_new ("Identity:");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = gtk_label_new (NULL);
gtk_label_set_attributes (GTK_LABEL (widget), bold);
gtk_label_set_ellipsize (GTK_LABEL (widget), PANGO_ELLIPSIZE_END);
gtk_label_set_selectable (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
viewer->viewing_label = widget; /* do not reference */
gtk_widget_show (widget);
widget = e_dialog_button_new_with_icon ("edit-delete", _("_Delete"));
gtk_box_pack_end (GTK_BOX (container), widget, FALSE, FALSE, 0);
viewer->delete_button = widget; /* do not reference */
gtk_widget_hide (widget);
/* Top panel: Deleting */
container = viewer->top_panel;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
page_num = gtk_notebook_append_page (
GTK_NOTEBOOK (container), widget, NULL);
g_warn_if_fail (page_num == PAGE_DELETING);
gtk_widget_show (widget);
container = widget;
widget = gtk_label_new ("Deleting");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = gtk_label_new (NULL);
gtk_label_set_attributes (GTK_LABEL (widget), bold);
gtk_label_set_ellipsize (GTK_LABEL (widget), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
viewer->deleting_label = widget; /* do not reference */
gtk_widget_show (widget);
widget = e_dialog_button_new_with_icon ("process-stop", _("_Cancel"));
gtk_box_pack_end (GTK_BOX (container), widget, FALSE, FALSE, 0);
viewer->deleting_cancel = widget; /* do not reference */
gtk_widget_show (widget);
pango_attr_list_unref (bold);
g_signal_connect (
selection, "changed",
G_CALLBACK (source_viewer_selection_changed_cb), viewer);
g_signal_connect (
viewer->delete_button, "clicked",
G_CALLBACK (source_viewer_delete_button_clicked_cb), viewer);
g_signal_connect (
viewer->deleting_cancel, "clicked",
G_CALLBACK (source_viewer_deleting_cancel_clicked_cb), viewer);
}
/* create a new tab */
static void tab_new(struct window *w) {
term *t;
int tmp;
char **args = 0;
const gchar *shell = g_getenv("SHELL");
if (!shell) {
shell = "sh";
}
g_shell_parse_argv(shell, 0, &args, 0);
t = g_new0(term, 1);
t->label = gtk_label_new("");
t->w = w;
t->vte = vte_terminal_new();
int index = gtk_notebook_append_page(GTK_NOTEBOOK(w->notebook), t->vte,
t->label);
gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(w->notebook), t->vte, TRUE);
if (index == 0) {
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(w->notebook), FALSE);
vte_terminal_fork_command_full(VTE_TERMINAL(t->vte),
VTE_PTY_DEFAULT, NULL,
args, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, t->pid, NULL);
tab_geometry_hints(t);
} else {
struct term *previous = get_nth_term(w, gtk_notebook_get_current_page(GTK_NOTEBOOK(w->notebook)));
vte_terminal_fork_command_full(VTE_TERMINAL(t->vte),
VTE_PTY_DEFAULT, tab_get_cwd(previous),
args, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, t->pid, NULL);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(w->notebook), TRUE);
}
g_object_set_qdata_full(G_OBJECT(gtk_notebook_get_nth_page(
(GtkNotebook*)w->notebook, index)), term_data_id, t, NULL);
g_signal_connect(G_OBJECT(t->vte), "child-exited", G_CALLBACK(tab_close), w);
g_signal_connect(G_OBJECT(t->vte), "window-title-changed", G_CALLBACK(tab_title), t);
g_signal_connect(G_OBJECT(t->vte), "button-press-event", G_CALLBACK(event_button), NULL);
vte_terminal_set_allow_bold(VTE_TERMINAL(t->vte), config->allow_bold);
vte_terminal_set_audible_bell(VTE_TERMINAL(t->vte), config->audible_bell);
vte_terminal_set_background_transparent(VTE_TERMINAL(t->vte),
config->bg_transparent);
vte_terminal_set_background_saturation(VTE_TERMINAL(t->vte), config->bg_saturation);
vte_terminal_set_background_image_file(VTE_TERMINAL(t->vte), config->bg_image);
vte_terminal_set_font_from_string(VTE_TERMINAL(t->vte), config->font);
vte_terminal_set_mouse_autohide(VTE_TERMINAL(t->vte),
config->autohide_mouse);
vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(t->vte),
config->scroll_on_keystroke);
vte_terminal_set_scroll_on_output(VTE_TERMINAL(t->vte),
config->scroll_on_output);
vte_terminal_set_scrollback_lines(VTE_TERMINAL(t->vte),
config->num_scrollback_lines);
vte_terminal_set_visible_bell(VTE_TERMINAL(t->vte), config->visible_bell);
vte_terminal_set_word_chars(VTE_TERMINAL(t->vte), config->word_chars);
vte_terminal_set_colors(VTE_TERMINAL(t->vte), &config->foreground,
&config->background, config->colour_palette, DEFAULT_PALETTE_SIZE);
tmp = vte_terminal_match_add_gregex(
VTE_TERMINAL(t->vte),
g_regex_new(config->url_regex, G_REGEX_CASELESS, G_REGEX_MATCH_NOTEMPTY,
NULL),
0);
vte_terminal_match_set_cursor_type(VTE_TERMINAL(t->vte), tmp,
GDK_HAND2);
gtk_widget_show_all(w->notebook);
gtk_notebook_set_current_page(GTK_NOTEBOOK(w->notebook), index);
gtk_widget_grab_focus(t->vte);
}
static void
cc_wacom_panel_init (CcWacomPanel *self)
{
CcWacomPanelPrivate *priv;
GtkNotebook *notebook;
GtkWidget *widget;
GList *devices, *l;
GError *error = NULL;
char *objects[] = {
"main-box",
NULL
};
priv = self->priv = WACOM_PANEL_PRIVATE (self);
g_resources_register (cc_wacom_get_resource ());
priv->builder = gtk_builder_new ();
gtk_builder_add_objects_from_resource (priv->builder,
"/org/gnome/control-center/wacom/gnome-wacom-properties.ui",
objects,
&error);
if (error != NULL)
{
g_warning ("Error loading UI file: %s", error->message);
g_object_unref (priv->builder);
g_error_free (error);
return;
}
priv->cancellable = g_cancellable_new ();
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.gnome.SettingsDaemon.Wacom",
"/org/gnome/SettingsDaemon/Wacom",
"org.gnome.SettingsDaemon.Wacom",
priv->cancellable,
got_wacom_proxy_cb,
self);
/* Notebook */
notebook = GTK_NOTEBOOK (gtk_notebook_new ());
priv->notebook = GTK_WIDGET (notebook);
gtk_notebook_set_show_tabs (notebook, FALSE);
gtk_notebook_set_show_border (notebook, FALSE);
gtk_widget_set_vexpand (GTK_WIDGET (notebook), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 0);
g_object_set (G_OBJECT (notebook),
"margin-top", 6,
"margin-end", 30,
"margin-start", 30,
"margin-bottom", 30,
NULL);
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (notebook));
gtk_widget_show (priv->notebook);
/* No tablets page */
widget = WID ("main-box");
enbiggen_label (GTK_LABEL (WID ("advice-label1")));
gtk_notebook_append_page (notebook, widget, NULL);
g_signal_connect (G_OBJECT (WID ("linkbutton")), "activate-link",
G_CALLBACK (link_activated), self);
priv->devices = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_object_unref);
priv->pages = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
priv->manager = gdk_display_get_device_manager (gdk_display_get_default ());
priv->device_added_id = g_signal_connect (G_OBJECT (priv->manager), "device-added",
G_CALLBACK (device_added_cb), self);
priv->device_removed_id = g_signal_connect (G_OBJECT (priv->manager), "device-removed",
G_CALLBACK (device_removed_cb), self);
devices = gdk_device_manager_list_devices (priv->manager, GDK_DEVICE_TYPE_SLAVE);
for (l = devices; l ; l = l->next)
add_known_device (self, l->data);
g_list_free (devices);
update_current_page (self);
}
GtkWidget *gui_create_sidebar(GtkWidget *paned)
{
GtkWidget *vbox1;
GtkWidget *scrolledwindow4;
GtkWidget *scrolledwindow_bm;
GtkWidget *title_label = NULL;
#ifndef USE_WEBKIT2
GtkWidget *scrolledwindow;
#endif
GtkWidget *table2;
UI_VBOX(vbox1, FALSE, 0);
gtk_widget_show(vbox1);
widgets.paned_sidebar = UI_VPANE();
gtk_paned_pack1(GTK_PANED(paned), widgets.paned_sidebar, FALSE,
TRUE);
gtk_widget_show(widgets.paned_sidebar);
gtk_paned_pack1(GTK_PANED(widgets.paned_sidebar), vbox1, FALSE,
TRUE);
UI_VBOX(widgets.box_side_preview, FALSE, 0);
gtk_paned_pack2(GTK_PANED(widgets.paned_sidebar),
widgets.box_side_preview, FALSE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(widgets.box_side_preview), 2);
g_signal_connect(G_OBJECT(widgets.paned_sidebar),
"button_release_event",
G_CALLBACK(paned_button_release_event),
(gchar *)"paned_sidebar");
widgets.shortcutbar = widgets.paned_sidebar;
#ifndef USE_WEBKIT2
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_box_pack_start(GTK_BOX(widgets.box_side_preview),
scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *)
scrolledwindow,
settings.shadow_type);
#endif
sidebar.html_viewer_widget =
GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, SB_VIEWER_TYPE));
gtk_widget_show(sidebar.html_viewer_widget);
#ifdef USE_WEBKIT2
gtk_box_pack_start(GTK_BOX(widgets.box_side_preview), sidebar.html_viewer_widget, TRUE, TRUE, 0);
#else
gtk_container_add(GTK_CONTAINER(scrolledwindow),
sidebar.html_viewer_widget);
#endif
/* ---------------------------------------------------------------- */
/* 2x2 button box set: modules/bookmarks/search/vlist */
/* ---------------------------------------------------------------- */
#ifdef HAVE_GTK_34
table2 = gtk_grid_new();
gtk_widget_show(table2);
gtk_box_pack_start(GTK_BOX(vbox1), table2, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(table2), 2);
gtk_grid_set_row_spacing(GTK_GRID(table2), 6);
gtk_grid_set_column_spacing(GTK_GRID(table2), 6);
gtk_grid_set_row_homogeneous(GTK_GRID(table2), TRUE);
gtk_grid_set_column_homogeneous(GTK_GRID(table2), TRUE);
button_bookmarks =
gtk_toggle_button_new_with_mnemonic(_("Bookmarks"));
gtk_widget_show(button_bookmarks);
gtk_grid_attach(GTK_GRID(table2), button_bookmarks, 1, 0, 1, 1);
gtk_button_set_relief(GTK_BUTTON(button_bookmarks),
GTK_RELIEF_HALF);
#ifdef HAVE_GTK_320
gtk_widget_set_focus_on_click(GTK_WIDGET(button_bookmarks), FALSE);
#else
gtk_button_set_focus_on_click(GTK_BUTTON(button_bookmarks), FALSE);
#endif
button_search = gtk_toggle_button_new_with_mnemonic(_("Search"));
gtk_widget_show(button_search);
gtk_grid_attach(GTK_GRID(table2), button_search, 0, 1, 1, 1);
gtk_button_set_relief(GTK_BUTTON(button_search), GTK_RELIEF_HALF);
#ifdef HAVE_GTK_320
gtk_widget_set_focus_on_click(GTK_WIDGET(button_search), FALSE);
#else
gtk_button_set_focus_on_click(GTK_BUTTON(button_search), FALSE);
#endif
button_v_lists =
gtk_toggle_button_new_with_mnemonic(_("Verse List"));
gtk_widget_show(button_v_lists);
gtk_grid_attach(GTK_GRID(table2), button_v_lists, 1, 1, 1, 1);
gtk_button_set_relief(GTK_BUTTON(button_v_lists), GTK_RELIEF_HALF);
#ifdef HAVE_GTK_320
gtk_widget_set_focus_on_click(GTK_WIDGET(button_v_lists), FALSE);
#else
gtk_button_set_focus_on_click(GTK_BUTTON(button_v_lists), FALSE);
#endif
button_modules = gtk_toggle_button_new_with_mnemonic(_("Modules"));
gtk_widget_show(button_modules);
gtk_grid_attach(GTK_GRID(table2), button_modules, 0, 0, 1, 1);
gtk_button_set_relief(GTK_BUTTON(button_modules), GTK_RELIEF_HALF);
#ifdef HAVE_GTK_320
gtk_widget_set_focus_on_click(GTK_WIDGET(button_modules), FALSE);
#else
gtk_button_set_focus_on_click(GTK_BUTTON(button_modules), FALSE);
#endif
#else
table2 = gtk_table_new(2, 2, TRUE);
gtk_widget_show(table2);
gtk_box_pack_start(GTK_BOX(vbox1), table2, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(table2), 2);
gtk_table_set_row_spacings(GTK_TABLE(table2), 6);
gtk_table_set_col_spacings(GTK_TABLE(table2), 6);
button_bookmarks =
gtk_toggle_button_new_with_mnemonic(_("Bookmarks"));
gtk_widget_show(button_bookmarks);
gtk_table_attach(GTK_TABLE(table2), button_bookmarks, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_button_set_relief(GTK_BUTTON(button_bookmarks),
GTK_RELIEF_HALF);
gtk_button_set_focus_on_click(GTK_BUTTON(button_bookmarks), FALSE);
button_search = gtk_toggle_button_new_with_mnemonic(_("Search"));
gtk_widget_show(button_search);
gtk_table_attach(GTK_TABLE(table2), button_search, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_button_set_relief(GTK_BUTTON(button_search), GTK_RELIEF_HALF);
gtk_button_set_focus_on_click(GTK_BUTTON(button_search), FALSE);
button_v_lists =
gtk_toggle_button_new_with_mnemonic(_("Verse List"));
gtk_widget_show(button_v_lists);
gtk_table_attach(GTK_TABLE(table2), button_v_lists, 1, 2, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_button_set_relief(GTK_BUTTON(button_v_lists), GTK_RELIEF_HALF);
gtk_button_set_focus_on_click(GTK_BUTTON(button_v_lists), FALSE);
button_modules = gtk_toggle_button_new_with_mnemonic(_("Modules"));
gtk_widget_show(button_modules);
gtk_table_attach(GTK_TABLE(table2), button_modules, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_button_set_relief(GTK_BUTTON(button_modules), GTK_RELIEF_HALF);
gtk_button_set_focus_on_click(GTK_BUTTON(button_modules), FALSE);
#endif
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_modules),
TRUE);
/* ---------------------------------------------------------------- */
widgets.notebook_sidebar = gtk_notebook_new();
gtk_widget_show(widgets.notebook_sidebar);
gtk_box_pack_start(GTK_BOX(vbox1), widgets.notebook_sidebar, TRUE,
TRUE, 0);
gtk_widget_set_can_default(widgets.notebook_sidebar, 1);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_sidebar),
FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_sidebar), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_sidebar), 2);
scrolledwindow4 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow4);
gtk_container_add(GTK_CONTAINER(widgets.notebook_sidebar),
scrolledwindow4);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow4),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *)
scrolledwindow4,
settings.shadow_type);
sidebar.module_list = gtk_tree_view_new();
gtk_widget_show(sidebar.module_list);
gtk_container_add(GTK_CONTAINER(scrolledwindow4),
sidebar.module_list);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(sidebar.module_list), FALSE);
main_create_pixbufs();
main_add_mod_tree_columns(GTK_TREE_VIEW(sidebar.module_list));
scrolledwindow_bm = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow_bm);
gtk_container_add(GTK_CONTAINER(widgets.notebook_sidebar),
scrolledwindow_bm);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow_bm),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *)
scrolledwindow_bm,
settings.shadow_type);
widgets.bookmark_tree = gui_create_bookmark_tree();
gtk_widget_show(widgets.bookmark_tree);
gtk_container_add(GTK_CONTAINER(scrolledwindow_bm),
widgets.bookmark_tree);
gui_create_search_sidebar();
create_search_results_page(widgets.notebook_sidebar);
main_load_module_tree(sidebar.module_list);
g_signal_connect_after((gpointer)sidebar.module_list,
"button_release_event",
G_CALLBACK(on_modules_list_button_release), NULL);
// sidebar.menu_modules = create_menu_modules();
sidebar.menu_prayerlist = create_menu_prayerlist();
sidebar.menu_prayerlist_mod = create_menu_prayerlist_mod();
g_signal_connect((gpointer)button_bookmarks, "toggled",
G_CALLBACK(on_bookmarks_activate), NULL);
g_signal_connect((gpointer)button_search, "toggled",
G_CALLBACK(on_search_activate), NULL);
g_signal_connect((gpointer)button_v_lists, "toggled",
G_CALLBACK(on_search_results_activate), NULL);
g_signal_connect((gpointer)button_modules, "toggled",
G_CALLBACK(on_modules_activate), NULL);
g_signal_connect((gpointer)widgets.notebook_sidebar,
"switch-page",
G_CALLBACK(on_notebook_switch_page), title_label);
return vbox1;
}
