void statusbar_update_state(DebugState state)
{
static DebugState last_state = DS_INACTIVE;
if (thread_state == THREAD_AT_ASSEMBLER)
state = DS_EXTRA_1;
if (state != last_state)
{
static const char *const states[] = { N_("Busy"), N_("Ready"), N_("Debug"),
N_("Hang"), N_("Assem"), N_("Load"), NULL };
guint i;
for (i = 0; states[i]; i++)
if (state & (DS_BUSY << i))
break;
gtk_label_set_text(debug_state_label, _(states[i]));
if (state == DS_INACTIVE)
{
gtk_widget_hide(debug_statusbar);
gtk_statusbar_set_has_resize_grip(geany_statusbar, TRUE);
}
else if (last_state == DS_INACTIVE)
{
gtk_statusbar_set_has_resize_grip(geany_statusbar, FALSE);
gtk_widget_show(debug_statusbar);
}
last_state = state;
}
}
GtkWidget *gui_status_build(void)
{
statusbar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(statusbar), FALSE);
context = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "info");
return statusbar;
}
VikStatusbar *vik_statusbar_new ()
{
VikStatusbar *vs = VIK_STATUSBAR ( g_object_new ( VIK_STATUSBAR_TYPE, NULL ) );
gint i;
for ( i = 0; i < VIK_STATUSBAR_NUM_TYPES; i++ ) {
vs->empty[i] = TRUE;
vs->status[i] = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip ( GTK_STATUSBAR(vs->status[i]), FALSE );
}
gtk_box_pack_start ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_TOOL], FALSE, FALSE, 1);
gtk_widget_set_size_request ( vs->status[VIK_STATUSBAR_TOOL], 150, -1 );
gtk_box_pack_start ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_ITEMS], FALSE, FALSE, 1);
gtk_widget_set_size_request ( vs->status[VIK_STATUSBAR_ITEMS], 100, -1 );
gtk_box_pack_start ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_ZOOM], FALSE, FALSE, 1);
gtk_widget_set_size_request ( vs->status[VIK_STATUSBAR_ZOOM], 100, -1 );
gtk_box_pack_start ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_POSITION], FALSE, FALSE, 1);
gtk_widget_set_size_request ( vs->status[VIK_STATUSBAR_POSITION], 250, -1 );
gtk_box_pack_end ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_INFO], TRUE, TRUE, 1);
// Set minimum overall size
// otherwise the individual size_requests above create an implicit overall size,
// and so one can't downsize horizontally as much as may be desired when the statusbar is on
gtk_widget_set_size_request ( GTK_WIDGET(vs), 50, -1 );
return vs;
}
static GtkWidget *build_status_bar(void)
{
GtkWidget *vsep;
app_bar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(app_bar), TRUE);
gtk_widget_show(app_bar);
vp_target_status = gtk_label_new("");
gtk_widget_show(vp_target_status);
gtk_box_pack_start(GTK_BOX(app_bar), vp_target_status, FALSE, TRUE,
0);
vsep = gtk_vseparator_new();
gtk_widget_show(vsep);
gtk_box_pack_start(GTK_BOX(app_bar), vsep, FALSE, TRUE, 0);
/* Network status: offline */
net_status = gtk_label_new(_("Offline"));
gtk_widget_show(net_status);
gtk_box_pack_start(GTK_BOX(app_bar), net_status, FALSE, TRUE, 0);
vsep = gtk_vseparator_new();
gtk_widget_show(vsep);
gtk_box_pack_start(GTK_BOX(app_bar), vsep, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(app_bar),
player_build_turn_area(), FALSE, TRUE, 0);
/* Initial text in status bar */
gui_set_instructions(_("Welcome to Pioneers!"));
return app_bar;
}
/** Initialize the data structures of a gnucash embedded window.
*
* @param window The object to initialize. */
static void
gnc_embedded_window_setup_window (GncEmbeddedWindow *window)
{
GncEmbeddedWindowPrivate *priv;
ENTER("window %p", window);
priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);
/* Create widgets and add them to the window */
gtk_widget_show (GTK_WIDGET(window));
priv->menu_dock = gtk_vbox_new (FALSE, 0);
gtk_widget_show (priv->menu_dock);
gtk_box_pack_start (GTK_BOX (window), priv->menu_dock, FALSE, TRUE, 0);
priv->statusbar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(priv->statusbar), FALSE);
gtk_widget_show (priv->statusbar);
gtk_box_pack_end (GTK_BOX (window), priv->statusbar, FALSE, TRUE, 0);
window->ui_merge = gtk_ui_manager_new ();
g_signal_connect (G_OBJECT (window->ui_merge), "add_widget",
G_CALLBACK (gnc_embedded_window_add_widget), window);
priv->action_group = NULL;
LEAVE(" ");
}
/**
* check on any change on the main window
* for now, only to check if we set/unset the full-screen
*
* \param window
* \param event
* \param null
*
* \return FALSE
* */
gboolean gsb_grisbi_change_state_window ( GtkWidget *window,
GdkEventWindowState *event,
gpointer null )
{
gboolean show;
if ( event->changed_mask & GDK_WINDOW_STATE_MAXIMIZED )
{
show = !( event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED );
gtk_statusbar_set_has_resize_grip ( GTK_STATUSBAR ( gsb_status_get_status_bar () ), show );
conf.maximize_screen = !show;
}
else if ( event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN )
{
show = !( event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN );
if ( show )
gtk_widget_show ( gsb_status_get_status_bar () );
else
gtk_widget_hide ( gsb_status_get_status_bar () );
conf.full_screen = !show;
}
/* return value */
return FALSE;
}
void
eom_statusbar_set_has_resize_grip (EomStatusbar *statusbar, gboolean has_resize_grip)
{
g_return_if_fail (EOM_IS_STATUSBAR (statusbar));
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (statusbar),
has_resize_grip);
}
static void
eom_statusbar_init (EomStatusbar *statusbar)
{
EomStatusbarPrivate *priv;
GtkWidget *vbox;
statusbar->priv = EOM_STATUSBAR_GET_PRIVATE (statusbar);
priv = statusbar->priv;
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (statusbar), TRUE);
priv->img_num_statusbar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (priv->img_num_statusbar), FALSE);
gtk_widget_set_size_request (priv->img_num_statusbar, 100, 10);
gtk_widget_show (priv->img_num_statusbar);
gtk_box_pack_end (GTK_BOX (statusbar),
priv->img_num_statusbar,
FALSE,
TRUE,
0);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (statusbar),
vbox,
FALSE,
FALSE,
2);
statusbar->priv->progressbar = gtk_progress_bar_new ();
gtk_box_pack_end (GTK_BOX (vbox),
priv->progressbar,
TRUE,
TRUE,
2);
gtk_widget_set_size_request (priv->progressbar, -1, 10);
gtk_widget_show (vbox);
gtk_widget_hide (statusbar->priv->progressbar);
}
GtkWidget *
gm_statusbar_new ()
{
GmStatusbar *sb = NULL;
sb = GM_STATUSBAR (g_object_new (GM_STATUSBAR_TYPE, NULL));
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (object), FALSE);
return GTK_WIDGET (sb);
}
static void
packets_bar_new(void)
{
/* tip: tooltips don't work on statusbars! */
packets_bar = gtk_statusbar_new();
packets_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(packets_bar), "packets");
packets_bar_update();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(packets_bar), FALSE);
gtk_widget_show(packets_bar);
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_statusbar_set_properties(GtkWidget *widget, GbWidgetSetArgData *data)
{
gboolean resize_grip;
resize_grip = gb_widget_input_bool (data, ResizeGrip);
if (data->apply)
{
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (widget), resize_grip);
}
}
void ctk_statusbar_init(CtkStatusBar *status_bar)
{
status_bar->widget = gtk_statusbar_new();
status_bar->prev_message_id = 0;
status_bar->enabled = TRUE;
#ifndef CTK_GTK3
gtk_statusbar_set_has_resize_grip
(GTK_STATUSBAR(status_bar->widget), FALSE);
#endif
}
GtkWidget *
gtk_create_status_bar(int *context_id, const gchar *context_str, char *msg1,
char *msg2) {
GtkWidget *status_bar = gtk_statusbar_new();
*context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar),
context_str);
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(status_bar), TRUE);
gtk_statusbar_push(GTK_STATUSBAR(status_bar), *context_id, msg2);
gtk_statusbar_push(GTK_STATUSBAR(status_bar), *context_id, msg1);
return status_bar;
}
void statusbar_update_state(DebugState state)
{
if (thread_state == THREAD_AT_ASSEMBLER)
state = DS_EXTRA_1;
if (state != last_statusbar_state)
{
static const char *const states[] = { N_("Busy"), N_("Ready"), N_("Debug"),
N_("Hang"), N_("Assem"), N_("Load"), NULL };
guint i;
for (i = 0; states[i]; i++)
if (state & (DS_BUSY << i))
break;
gtk_label_set_text(debug_state_label, _(states[i]));
if (state == DS_INACTIVE)
{
gtk_widget_hide(debug_statusbar);
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_window_set_has_resize_grip(GTK_WINDOW(geany->main_widgets->window), TRUE);
#else
gtk_statusbar_set_has_resize_grip(geany_statusbar, TRUE);
#endif
}
else if (last_statusbar_state == DS_INACTIVE)
{
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_window_set_has_resize_grip(GTK_WINDOW(geany->main_widgets->window), FALSE);
#else
gtk_statusbar_set_has_resize_grip(geany_statusbar, FALSE);
#endif
gtk_widget_show(debug_statusbar);
}
last_statusbar_state = state;
}
}
static void
update_resize_grip (GtkWidget *widget,
GdkEventWindowState *event,
GtkStatusbar *statusbar)
{
if (event->changed_mask & (GDK_WINDOW_STATE_MAXIMIZED |
GDK_WINDOW_STATE_FULLSCREEN))
{
gboolean maximized;
maximized = event->new_window_state & (GDK_WINDOW_STATE_MAXIMIZED |
GDK_WINDOW_STATE_FULLSCREEN);
gtk_statusbar_set_has_resize_grip (statusbar, !maximized);
}
}
static void
info_bar_new(void)
{
info_bar_event = gtk_event_box_new();
info_bar = gtk_statusbar_new();
gtk_container_add(GTK_CONTAINER(info_bar_event), info_bar);
main_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "main");
file_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "file");
help_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "help");
filter_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "filter");
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(info_bar), FALSE);
gtk_statusbar_push(GTK_STATUSBAR(info_bar), main_ctx, DEF_READY_MESSAGE);
memset(status_levels, 0, sizeof(status_levels));
gtk_widget_show(info_bar);
gtk_widget_show(info_bar_event);
}
static void
profile_bar_new(void)
{
profile_bar_event = gtk_event_box_new();
profile_bar = gtk_statusbar_new();
gtk_container_add(GTK_CONTAINER(profile_bar_event), profile_bar);
g_signal_connect(profile_bar_event, "button_press_event", G_CALLBACK(profile_show_popup_cb), NULL);
g_signal_connect(profile_bar_event, "button_press_event", G_CALLBACK(popup_menu_handler),
g_object_get_data(G_OBJECT(popup_menu_object), PM_STATUSBAR_PROFILES_KEY));
profile_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(profile_bar), "profile");
gtk_widget_set_tooltip_text(profile_bar_event, "Click to change configuration profile");
profile_bar_update();
#if !GTK_CHECK_VERSION(3,0,0)
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(profile_bar), FALSE);
#endif
gtk_widget_show(profile_bar);
gtk_widget_show(profile_bar_event);
}
static void
info_bar_new(void)
{
int i;
/* tip: tooltips don't work on statusbars! */
info_bar = gtk_statusbar_new();
main_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "main");
file_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "file");
help_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "help");
filter_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "filter");
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(info_bar), FALSE);
gtk_statusbar_push(GTK_STATUSBAR(info_bar), main_ctx, DEF_READY_MESSAGE);
for (i = 0; i < NUM_STATUS_LEVELS; i++) {
status_levels[i] = 0;
}
gtk_widget_show(info_bar);
}
GtkWidget *
gu_statusbar_add(gu_window_t *gw, GtkWidget *parent)
{
statusbar_t *sb = calloc(1, sizeof(statusbar_t));
sb->bar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(sb->bar), TRUE);
gtk_box_pack_start(GTK_BOX(parent), sb->bar, FALSE, TRUE, 0);
sb->ctxid = gtk_statusbar_get_context_id(GTK_STATUSBAR(sb->bar),
"notifications");
prop_subscribe(0,
PROP_TAG_NAME("global", "notifications", "nodes"),
PROP_TAG_CALLBACK, notifications_update, sb,
PROP_TAG_COURIER, gw->gw_gu->gu_pc,
NULL);
return sb->bar;
}
static void
info_bar_new(void)
{
int i;
info_bar_event = gtk_event_box_new();
info_bar = gtk_statusbar_new();
gtk_container_add(GTK_CONTAINER(info_bar_event), info_bar);
main_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "main");
file_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "file");
help_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "help");
filter_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "filter");
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(info_bar), FALSE);
gtk_statusbar_push(GTK_STATUSBAR(info_bar), main_ctx, DEF_READY_MESSAGE);
for (i = 0; i < NUM_STATUS_LEVELS; i++) {
status_levels[i] = 0;
}
gtk_widget_show(info_bar);
gtk_widget_show(info_bar_event);
}
GtkWidget *statusbar_create(void)
{
GtkWidget *statusbar;
GtkWidget *child;
GtkWidget *parent;
GtkWidget *hbox;
statusbar = gtk_statusbar_new();
statusbar_list = g_list_append(statusbar_list, statusbar);
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(statusbar),
FALSE);
gtk_container_set_border_width(GTK_CONTAINER(statusbar), 1);
child = gtk_statusbar_get_message_area(GTK_STATUSBAR(statusbar));
parent = gtk_widget_get_parent(child);
gtk_container_remove(GTK_CONTAINER(parent), g_object_ref(child));
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(parent), hbox);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(hbox), child, TRUE, TRUE, 0);
g_object_unref(child);
return statusbar;
}
/**
* gnobots_statusbar_new
*
* Description:
* creates a new statusbar
*
* Returns:
* a pointer to the statusbar or NULL on failure
**/
GtkWidget *
gnobots_statusbar_new (void)
{
GtkWidget *label;
if (statusbar != NULL) {
return statusbar;
}
sbtbl = gtk_table_new (1, 11, FALSE);
label = gtk_label_new (_("Score:"));
gtk_table_attach (GTK_TABLE (sbtbl), label, 0, 1, 0, 1, 0, 0, 3, 3);
gtk_widget_show (label);
score_label = gtk_label_new ("0");
gtk_table_attach (GTK_TABLE (sbtbl), score_label, 1, 2, 0, 1, 0, 0, 3, 3);
gtk_widget_show (score_label);
gtk_table_set_col_spacing (GTK_TABLE (sbtbl), 2, 12);
label = gtk_label_new (_("Safe Teleports:"));
gtk_table_attach (GTK_TABLE (sbtbl), label, 3, 4, 0, 1, 0, 0, 3, 3);
gtk_widget_show (label);
safe_label = gtk_label_new ("0");
gtk_table_attach (GTK_TABLE (sbtbl), safe_label, 4, 5, 0, 1, 0, 0, 3, 3);
gtk_widget_show (safe_label);
gtk_table_set_col_spacing (GTK_TABLE (sbtbl), 5, 12);
label = gtk_label_new (_("Level:"));
gtk_table_attach (GTK_TABLE (sbtbl), label, 6, 7, 0, 1, 0, 0, 3, 3);
gtk_widget_show (label);
level_label = gtk_label_new ("0");
gtk_table_attach (GTK_TABLE (sbtbl), level_label, 7, 8, 0, 1, 0, 0, 3, 3);
gtk_widget_show (level_label);
gtk_table_set_col_spacing (GTK_TABLE (sbtbl), 8, 12);
label = gtk_label_new (_("Remaining:"));
gtk_table_attach (GTK_TABLE (sbtbl), label, 9, 10, 0, 1, 0, 0, 3, 3);
gtk_widget_show (label);
remaining_label = gtk_label_new ("0");
gtk_table_attach (GTK_TABLE (sbtbl), remaining_label,
10, 11, 0, 1, 0, 0, 3, 3);
gtk_widget_show (remaining_label);
gtk_widget_show (sbtbl);
statusbar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (statusbar), FALSE);
gtk_box_pack_start (GTK_BOX (statusbar), sbtbl, FALSE, FALSE, 0);
show_both = TRUE;
gnobots_statusbar_reset ();
return statusbar;
}
void create_mainwindow(void)
{
char *imagename;
GtkWidget *vbox_gs;
GtkWidget *menu;
GtkWidget *hbox25;
GtkWidget *tab_button_icon;
GtkWidget *label;
#ifndef USE_WEBKIT2
GtkWidget *scrolledwindow;
#endif
GtkWidget *box_book;
GdkPixbuf *pixbuf;
/*
GTK_SHADOW_NONE
GTK_SHADOW_IN
GTK_SHADOW_OUT
GTK_SHADOW_ETCHED_IN
GTK_SHADOW_ETCHED_OUT
*/
settings.shadow_type = GTK_SHADOW_IN;
XI_print(("%s xiphos-%s\n", "Starting", VERSION));
XI_print(("%s\n\n", "Building Xiphos interface"));
widgets.studypad_dialog = NULL;
/* A rough scektch of the main window (widgets.app) and it's children
* widgets.app
* |
* vbox_gs
* |
* +--|----+
* | |
* menu hbox25
* |
* widgets.epaned
* |
* widgets.vboxMain
* | |
* widgets.hboxtb widgets.page
* | |
* widgets.hpaned nav_toolbar
* | |
* widgets.vpaned---+ +----------------------------widgets.vpaned2---------------+
* | | | |
* widgets.vbox_previewer widgets.vbox_text widgets.notebook_comm_book widgets.box_dict
* | | |
* widgets.notebook_bible_parallel widgets.box_comm box_book
* |
* widgets.notebook_text
*
*/
// The toplevel Xiphos window
widgets.app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(widgets.app), _("Xiphos - Bible Study Software"));
g_object_set_data(G_OBJECT(widgets.app), "widgets.app", widgets.app);
gtk_widget_set_size_request(widgets.app, 680, 425);
gtk_widget_set_can_focus(widgets.app, 1);
gtk_window_set_resizable(GTK_WINDOW(widgets.app), TRUE);
// The app icon.
// FIXME:: This should be a big copy of the logo because GTK does the scaling (GTK 3.16?)
imagename = image_locator("gs2-48x48.png");
pixbuf = gdk_pixbuf_new_from_file(imagename, NULL);
g_free(imagename);
gtk_window_set_icon(GTK_WINDOW(widgets.app), pixbuf);
// The main box for our toplevel window.
UI_VBOX(vbox_gs, FALSE, 0);
gtk_widget_show(vbox_gs);
gtk_container_add(GTK_CONTAINER(widgets.app), vbox_gs);
// Add the main menu.
menu = gui_create_main_menu();
gtk_box_pack_start(GTK_BOX(vbox_gs), menu, FALSE, TRUE, 0);
// Another box
UI_HBOX(hbox25, FALSE, 0);
gtk_widget_show(hbox25);
gtk_box_pack_start(GTK_BOX(vbox_gs), hbox25, TRUE, TRUE, 0);
// widgets.epaned
widgets.epaned = UI_HPANE();
gtk_widget_show(widgets.epaned);
#ifndef HAVE_GTK_314
gtk_container_set_border_width(GTK_CONTAINER(widgets.epaned), 4);
#endif
gtk_box_pack_start(GTK_BOX(hbox25), widgets.epaned, TRUE, TRUE, 0);
// Another box
UI_VBOX(widgets.vboxMain, FALSE, 0);
gtk_widget_show(widgets.vboxMain);
gtk_paned_pack2(GTK_PANED(widgets.epaned), widgets.vboxMain, TRUE, TRUE);
#ifndef HAVE_GTK_314
gtk_container_set_border_width(GTK_CONTAINER(widgets.vboxMain), 2);
#endif
/*
* Notebook to have separate passages opened at once the passages are not
* actually open but are switched between similar to bookmarks
*/
UI_HBOX(widgets.hboxtb, FALSE, 0);
if (settings.browsing)
gtk_widget_show(widgets.hboxtb);
gtk_box_pack_start(GTK_BOX(widgets.vboxMain), widgets.hboxtb, FALSE, FALSE, 0);
widgets.button_new_tab = gtk_button_new();
// Don't show button here in case !settings.browsing
#ifdef HAVE_GTK_310
tab_button_icon = gtk_image_new_from_icon_name("tab-new-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
#else
tab_button_icon = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_SMALL_TOOLBAR);
#endif
gtk_widget_show(tab_button_icon);
gtk_container_add(GTK_CONTAINER(widgets.button_new_tab), tab_button_icon);
gtk_button_set_relief(GTK_BUTTON(widgets.button_new_tab), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(widgets.hboxtb), widgets.button_new_tab, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(widgets.button_new_tab, _("Open a new tab"));
widgets.notebook_main = gtk_notebook_new();
gtk_widget_show(widgets.notebook_main);
gtk_box_pack_start(GTK_BOX(widgets.hboxtb), widgets.notebook_main, TRUE, TRUE, 0);
gtk_widget_set_size_request(widgets.notebook_main, -1, 25);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(widgets.notebook_main), TRUE);
gtk_notebook_popup_enable(GTK_NOTEBOOK(widgets.notebook_main));
gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_main), FALSE);
// Main passage tabbed notebook end
// Another box
UI_VBOX(widgets.page, FALSE, 0);
gtk_widget_show(widgets.page);
gtk_box_pack_start(GTK_BOX(widgets.vboxMain), widgets.page, TRUE, TRUE, 0);
//nav toolbar
nav_toolbar = gui_navbar_versekey_new();
gtk_box_pack_start(GTK_BOX(widgets.page), nav_toolbar, FALSE, FALSE, 0);
// widgets.hpaned
widgets.hpaned = UI_HPANE();
gtk_widget_show(widgets.hpaned);
gtk_box_pack_start(GTK_BOX(widgets.page), widgets.hpaned, TRUE, TRUE, 0);
// widgets.vpaned
widgets.vpaned = UI_VPANE();
gtk_widget_show(widgets.vpaned);
gtk_widget_set_size_request(widgets.vpaned, 50, -1);
gtk_paned_pack1(GTK_PANED(widgets.hpaned), widgets.vpaned, TRUE, FALSE);
// widgets.vpaned2
widgets.vpaned2 = UI_VPANE();
gtk_widget_show(widgets.vpaned2);
gtk_widget_set_size_request(widgets.vpaned2, 50, -1);
gtk_paned_pack2(GTK_PANED(widgets.hpaned), widgets.vpaned2, TRUE, FALSE);
// widgets.vbox_text
UI_VBOX(widgets.vbox_text, FALSE, 0);
gtk_widget_show(widgets.vbox_text);
gtk_paned_pack1(GTK_PANED(widgets.vpaned), widgets.vbox_text, TRUE, TRUE);
// Bible/parallel notebook
widgets.notebook_bible_parallel = gtk_notebook_new();
gtk_widget_show(widgets.notebook_bible_parallel);
gtk_box_pack_start(GTK_BOX(widgets.vbox_text), widgets.notebook_bible_parallel, TRUE, TRUE, 0);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(widgets.notebook_bible_parallel), GTK_POS_BOTTOM);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_bible_parallel), TRUE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_bible_parallel), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_bible_parallel), 1);
g_signal_connect(G_OBJECT(widgets.notebook_bible_parallel), "change-current-page", G_CALLBACK(on_notebook_bible_parallel_switch_page), NULL);
// Text notebook (The bible text show in the standard view)
widgets.notebook_text = gui_create_bible_pane();
gtk_container_add(GTK_CONTAINER(widgets.notebook_bible_parallel), widgets.notebook_text);
label = gtk_label_new(_("Standard View"));
gtk_widget_show(label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_bible_parallel), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_bible_parallel), 0), label);
// Another box (For the previewer?)
UI_VBOX(widgets.vbox_previewer, FALSE, 0);
gtk_widget_show(widgets.vbox_previewer);
gtk_paned_pack2(GTK_PANED(widgets.vpaned), widgets.vbox_previewer, TRUE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(widgets.vbox_previewer), 2);
#ifndef USE_WEBKIT2
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_box_pack_start(GTK_BOX(widgets.vbox_previewer), 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
widgets.html_previewer_text = GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, VIEWER_TYPE));
gtk_widget_show(widgets.html_previewer_text);
#ifdef USE_WEBKIT2
gtk_box_pack_start(GTK_BOX(widgets.vbox_previewer), widgets.html_previewer_text, TRUE, TRUE, 0);
#else
gtk_container_add(GTK_CONTAINER(scrolledwindow), widgets.html_previewer_text);
#endif
// Commentary/book notebook
widgets.notebook_comm_book = gtk_notebook_new();
gtk_widget_show(widgets.notebook_comm_book);
gtk_paned_pack1(GTK_PANED(widgets.vpaned2), widgets.notebook_comm_book, TRUE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_comm_book), 1);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(widgets.notebook_comm_book), GTK_POS_BOTTOM);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_comm_book), TRUE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_comm_book), FALSE);
// Commentary pane
widgets.box_comm = gui_create_commentary_pane();
gtk_container_add(GTK_CONTAINER(widgets.notebook_comm_book), widgets.box_comm);
label = gtk_label_new(_("Commentary View"));
gtk_widget_show(label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_comm_book), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_comm_book), 0), label);
// Book pane
box_book = gui_create_book_pane();
gtk_container_add(GTK_CONTAINER(widgets.notebook_comm_book), box_book);
label = gtk_label_new(_("Book View"));
gtk_widget_show(label);
gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_comm_book), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_comm_book), 1), label);
// Dict/lex
widgets.box_dict = gui_create_dictionary_pane();
gtk_paned_pack2(GTK_PANED(widgets.vpaned2), widgets.box_dict, TRUE, TRUE);
// Statusbar
widgets.appbar = gtk_statusbar_new();
if (settings.statusbar) {
gtk_widget_show(widgets.appbar);
}
#ifndef USE_GTK_3
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(widgets.appbar), TRUE);
#endif
gtk_box_pack_start(GTK_BOX(vbox_gs), widgets.appbar, FALSE, TRUE, 0);
gui_set_statusbar(_("Welcome to Xiphos"));
g_signal_connect((gpointer)vbox_gs, "key_press_event", G_CALLBACK(on_vbox1_key_press_event), NULL);
g_signal_connect((gpointer)vbox_gs, "key_release_event", G_CALLBACK(on_vbox1_key_release_event), NULL);
g_signal_connect(G_OBJECT(widgets.notebook_comm_book), "switch_page", G_CALLBACK(on_notebook_comm_book_switch_page), NULL);
g_signal_connect(G_OBJECT(widgets.app), "delete_event", G_CALLBACK(delete_event), NULL);
g_signal_connect((gpointer)widgets.app, "configure_event", G_CALLBACK(on_configure_event), NULL);
g_signal_connect(G_OBJECT(widgets.epaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"epaned");
g_signal_connect(G_OBJECT(widgets.vpaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"vpaned");
g_signal_connect(G_OBJECT(widgets.vpaned2), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"vpaned2");
g_signal_connect(G_OBJECT(widgets.hpaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"hpaned1");
gtk_widget_grab_focus(navbar_versekey.lookup_entry);
gtk_window_set_default_size((GtkWindow *)widgets.app, settings.gs_width, settings.gs_height);
main_window_created = TRUE;
}
void
SetupUI::create_main_ui ()
{
GtkWidget *hpaned1;
GtkWidget *scrolledwindow1;
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *frame1;
GtkWidget *hbox1;
GtkWidget *ok_button;
GtkWidget *exit_button;
GtkWidget *vseparator1;
GdkPixbuf *icon;
GtkCellRenderer *module_list_cell;
GtkTreeViewColumn *module_list_column;
// Create main window.
m_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (m_main_window), _("SCIM Input Method Setup"));
gtk_window_set_position (GTK_WINDOW (m_main_window), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (m_main_window), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (m_main_window), TRUE);
gtk_window_set_resizable (GTK_WINDOW (m_main_window), TRUE);
// Set the window icon
icon = gdk_pixbuf_new_from_file (SCIM_TRADEMARK_ICON_FILE, NULL);
if (icon) {
gtk_window_set_icon (GTK_WINDOW (m_main_window), icon);
g_object_unref (icon);
}
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (m_main_window), vbox1);
// Create paned window.
hpaned1 = gtk_hpaned_new ();
gtk_widget_show (hpaned1);
gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hpaned1), 4);
// Create statusbar.
m_status_bar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (m_status_bar), TRUE);
gtk_widget_show (m_status_bar);
gtk_box_pack_start (GTK_BOX (vbox1), m_status_bar, FALSE, FALSE, 0);
// Create scrollwindow for module list.
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow1);
gtk_paned_pack1 (GTK_PANED (hpaned1), scrolledwindow1, FALSE, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1),
GTK_SHADOW_ETCHED_IN);
// Create module list view.
m_module_list_view = gtk_tree_view_new ();
gtk_widget_show (m_module_list_view);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), m_module_list_view);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (m_module_list_view), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (m_module_list_view), FALSE);
// Get module list selection.
m_module_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_module_list_view));
gtk_tree_selection_set_mode (m_module_list_selection, GTK_SELECTION_BROWSE);
// Create module list column.
module_list_cell = gtk_cell_renderer_text_new ();
module_list_column = gtk_tree_view_column_new_with_attributes (
NULL, module_list_cell, "text", MODULE_LIST_LABEL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (m_module_list_view), module_list_column);
// Create vbox for work area and button area.
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_paned_pack2 (GTK_PANED (hpaned1), vbox2, TRUE, FALSE);
// Create frame for work area.
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox2), frame1, TRUE, TRUE, 0);
m_work_area = gtk_vbox_new (FALSE, 0);
gtk_widget_show (m_work_area);
gtk_container_add (GTK_CONTAINER (frame1), m_work_area);
// Create hbox for button area.
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_end (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 8);
ok_button = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (ok_button);
gtk_box_pack_end (GTK_BOX (hbox1), ok_button, FALSE, FALSE, 4);
exit_button = gtk_button_new_from_stock ("gtk-quit");
gtk_widget_show (exit_button);
gtk_box_pack_end (GTK_BOX (hbox1), exit_button, FALSE, FALSE, 4);
vseparator1 = gtk_vseparator_new ();
gtk_widget_show (vseparator1);
gtk_box_pack_end (GTK_BOX (hbox1), vseparator1, FALSE, FALSE, 4);
m_apply_button = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (m_apply_button);
gtk_box_pack_end (GTK_BOX (hbox1), m_apply_button, FALSE, FALSE, 4);
GTK_WIDGET_SET_FLAGS (m_apply_button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive (m_apply_button, FALSE);
m_restore_button = gtk_button_new_from_stock ("gtk-revert-to-saved");
gtk_widget_show (m_restore_button);
gtk_box_pack_end (GTK_BOX (hbox1), m_restore_button, FALSE, FALSE, 4);
gtk_widget_set_sensitive (m_restore_button, FALSE);
g_signal_connect ((gpointer) ok_button, "clicked",
G_CALLBACK (SetupUI::ok_button_clicked_callback),
this);
g_signal_connect ((gpointer) exit_button, "clicked",
G_CALLBACK (SetupUI::exit_button_clicked_callback),
this);
g_signal_connect ((gpointer) m_apply_button, "clicked",
G_CALLBACK (SetupUI::apply_button_clicked_callback),
this);
g_signal_connect ((gpointer) m_restore_button, "clicked",
G_CALLBACK (SetupUI::restore_button_clicked_callback),
this);
g_signal_connect (G_OBJECT (m_main_window), "delete_event",
G_CALLBACK (main_window_delete_callback),
this);
g_signal_connect (G_OBJECT (m_module_list_selection), "changed",
G_CALLBACK (module_list_selection_changed_callback),
this);
gtk_widget_grab_default (m_apply_button);
}
static void
wikipad_statusbar_init (WikipadStatusbar *statusbar)
{
GtkWidget *ebox, *box, *separator, *label;
GtkStatusbar *bar = GTK_STATUSBAR (statusbar);
GList *frame;
/* init statusbar */
#if ! GTK_CHECK_VERSION(3, 0, 0)
gtk_statusbar_set_has_resize_grip (bar, TRUE);
#endif
/* create a new horizontal box */
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_widget_show (box);
/* reorder the gtk statusbar */
frame = gtk_container_get_children (GTK_CONTAINER (bar));
gtk_frame_set_shadow_type (GTK_FRAME (frame->data), GTK_SHADOW_NONE);
label = gtk_bin_get_child (GTK_BIN (frame->data));
g_object_ref (label);
gtk_container_remove (GTK_CONTAINER (frame->data), label);
gtk_container_add (GTK_CONTAINER (frame->data), box);
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
g_object_unref (label);
g_list_free (frame);
/* separator */
separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, 0);
gtk_widget_show (separator);
/* language/filetype event box */
ebox = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, TRUE, 0);
gtk_event_box_set_visible_window (GTK_EVENT_BOX (ebox), FALSE);
gtk_widget_set_tooltip_text (ebox, _("Choose a filetype"));
g_signal_connect (G_OBJECT (ebox), "button-press-event", G_CALLBACK (wikipad_statusbar_filetype_clicked), statusbar);
gtk_widget_show (ebox);
/* language/filetype */
statusbar->language = gtk_label_new (_("Filetype: None"));
gtk_container_add (GTK_CONTAINER (ebox), statusbar->language);
gtk_widget_show (statusbar->language);
/* separator */
separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, 0);
gtk_widget_show (separator);
/* line and column numbers */
statusbar->position = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (box), statusbar->position, FALSE, TRUE, 0);
gtk_widget_show (statusbar->position);
/* separator */
separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, 0);
gtk_widget_show (separator);
/* overwrite event box */
ebox = gtk_event_box_new ();
gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, TRUE, 0);
gtk_event_box_set_visible_window (GTK_EVENT_BOX (ebox), FALSE);
gtk_widget_set_tooltip_text (ebox, _("Toggle the overwrite mode"));
g_signal_connect (G_OBJECT (ebox), "button-press-event", G_CALLBACK (wikipad_statusbar_overwrite_clicked), statusbar);
gtk_widget_show (ebox);
/* overwrite label */
statusbar->overwrite = gtk_label_new (_("OVR"));
gtk_container_add (GTK_CONTAINER (ebox), statusbar->overwrite);
gtk_widget_show (statusbar->overwrite);
}
void
app_new(int argc, char *argv[], const char *geometry_string)
{
GtkWidget *vbox;
GtkWidget *widget;
GtkWidget *vpane;
GtkWidget *separator;
GtkLabel *filler;
GtkHBox *labels;
GtkVBox *status_vbox;
GtkStatusbar *grip;
app_window = gnome_app_new(GTT_APP_NAME, GTT_APP_TITLE " " VERSION);
gtk_window_set_wmclass(GTK_WINDOW(app_window),
GTT_APP_NAME, GTT_APP_PROPER_NAME);
/* 485 x 272 seems to be a good size to default to */
gtk_window_set_default_size(GTK_WINDOW(app_window), 485, 272);
gtk_window_set_resizable (GTK_WINDOW(app_window), TRUE);
/* build menus */
menus_create(GNOME_APP(app_window));
/* build toolbar */
widget = build_toolbar();
gtk_widget_show(widget);
gnome_app_set_toolbar(GNOME_APP(app_window), GTK_TOOLBAR(widget));
/* container holds status bar, main ctree widget */
vbox = gtk_vbox_new(FALSE, 0);
/* build statusbar */
status_vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
gtk_widget_show(GTK_WIDGET(status_vbox));
labels = GTK_HBOX(gtk_hbox_new(FALSE, 0));
gtk_widget_show(GTK_WIDGET(labels));
status_bar = gtk_hbox_new(FALSE, 0);
gtk_widget_show(status_bar);
separator = gtk_hseparator_new();
gtk_widget_show(separator);
gtk_box_pack_start(GTK_BOX(status_vbox), separator, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(status_vbox), GTK_WIDGET (labels), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(status_bar), GTK_WIDGET (status_vbox), TRUE, TRUE, 0);
grip = GTK_STATUSBAR(gtk_statusbar_new());
gtk_statusbar_set_has_resize_grip(grip, TRUE);
gtk_widget_show(GTK_WIDGET(grip));
gtk_box_pack_start(GTK_BOX(status_bar), GTK_WIDGET(grip), FALSE, FALSE, 0);
/* put elapsed time into statusbar */
status_day_time = GTK_LABEL(gtk_label_new(_("00:00")));
gtk_widget_show(GTK_WIDGET(status_day_time));
gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(status_day_time),
FALSE, TRUE, 0);
/* put project name into statusbar */
status_project = GTK_LABEL(gtk_label_new( _("Timer is not running")));
gtk_widget_show(GTK_WIDGET(status_project));
gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(status_project),
FALSE, TRUE, 10);
filler = GTK_LABEL(gtk_label_new(""));
gtk_widget_show(GTK_WIDGET(filler));
gtk_box_pack_start(GTK_BOX(labels), GTK_WIDGET(filler), TRUE, TRUE, 1);
/* put timer icon into statusbar */
status_timer = gtk_image_new_from_stock (GNOME_STOCK_TIMER,
GTK_ICON_SIZE_MENU);
gtk_widget_show(status_timer);
gtk_box_pack_end(GTK_BOX(status_bar), GTK_WIDGET(status_timer),
FALSE, FALSE, 1);
/* create the main columned tree for showing projects */
projects_tree = gtt_projects_tree_new ();
g_signal_connect (projects_tree, "columns-setup-done", G_CALLBACK (projects_tree_columns_setup_done), NULL);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (projects_tree), TRUE);
g_signal_connect (projects_tree, "row-activated", G_CALLBACK (projects_tree_row_activated), NULL);
/* create the notes area */
global_na = notes_area_new();
vpane = notes_area_get_widget (global_na);
/* Need to reparent, to get rid of glade parent-window hack.
* But gtk_widget_reparent (vpane); causes a "Gtk-CRITICAL"
* to occur. So we need a fancier move.
*/
gtk_widget_ref (vpane);
gtk_container_remove(GTK_CONTAINER(vpane->parent), vpane);
gtk_box_pack_start(GTK_BOX(vbox), vpane, TRUE, TRUE, 0);
gtk_widget_unref (vpane);
gtk_box_pack_end(GTK_BOX(vbox), status_bar, FALSE, FALSE, 2);
notes_area_add_projects_tree (global_na, projects_tree);
/* we are done building it, make it visible */
gtk_widget_show(vbox);
gnome_app_set_contents(GNOME_APP(app_window), vbox);
gtt_status_icon_create();
if (!geometry_string) return;
if (gtk_window_parse_geometry(GTK_WINDOW(app_window),geometry_string))
{
geom_size_override=TRUE;
}
else
{
gnome_app_error(GNOME_APP(app_window),
_("Couldn't understand geometry (position and size)\n"
" specified on command line"));
}
}
int WebBrowserObject::BrowserOpen(void)
{
Lock();
if (!area.w) {
area.w = systemObject->configGetInt("video_width", systemObject->GetScreenWidth());
}
if (!area.h) {
area.h = systemObject->configGetInt("video_height", systemObject->GetScreenHeight());
}
if (!toplevel) {
toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(toplevel);
gdk_window_set_decorations(toplevel->window, (GdkWMDecoration)0);
toplevelVBox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(toplevel), toplevelVBox);
mozilla = gtk_moz_embed_new();
gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(mozilla), GTK_MOZ_EMBED_FLAG_ALLCHROME);
toolbarHBox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(toplevelVBox), toolbarHBox, FALSE, FALSE, 0);
toolbar = gtk_toolbar_new();
g_object_ref(toolbar);
gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);
if (toolbar_flag) {
gtk_box_pack_start(GTK_BOX(toolbarHBox), toolbar, FALSE, FALSE, 0);
}
backButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Back", "Go Back", "Go Back", 0, GTK_SIGNAL_FUNC(back_clicked_cb), this);
stopButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Stop", "Stop", "Stop", 0, GTK_SIGNAL_FUNC(stop_clicked_cb), this);
forwardButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Forward", "Forward", "Forward", 0, GTK_SIGNAL_FUNC(forward_clicked_cb), this);
reloadButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Reload", "Reload", "Reload", 0, GTK_SIGNAL_FUNC(reload_clicked_cb), this);
closeButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Close", "Close window", "Close window", 0, GTK_SIGNAL_FUNC(close_clicked_cb), this);
urlEntry = gtk_entry_new();
g_object_ref(urlEntry);
if (toolbar_flag) {
gtk_box_pack_start(GTK_BOX(toolbarHBox), urlEntry, TRUE, TRUE, 0);
}
gtk_box_pack_start(GTK_BOX(toplevelVBox), mozilla, TRUE, TRUE, 0);
progressAreaHBox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(toplevelVBox), progressAreaHBox, FALSE, FALSE, 0);
progressBar = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(progressAreaHBox), progressBar, FALSE, FALSE, 0);
statusAlign = gtk_alignment_new(0, 0, 1, 1);
gtk_widget_set_usize(statusAlign, 1, -1);
statusBar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(statusBar), 0);
gtk_container_add(GTK_CONTAINER(statusAlign), statusBar);
gtk_box_pack_start(GTK_BOX(progressAreaHBox), statusAlign, TRUE, TRUE, 0);
gtk_widget_set_sensitive(closeButton, TRUE);
gtk_widget_set_sensitive(backButton, FALSE);
gtk_widget_set_sensitive(stopButton, FALSE);
gtk_widget_set_sensitive(forwardButton, FALSE);
gtk_widget_set_sensitive(reloadButton, FALSE);
gtk_signal_connect(GTK_OBJECT(urlEntry), "activate", GTK_SIGNAL_FUNC(url_activate_cb), this);
gtk_signal_connect(GTK_OBJECT(toplevel), "delete_event", GTK_SIGNAL_FUNC(delete_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "destroy", GTK_SIGNAL_FUNC(destroy_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "destroy_browser", GTK_SIGNAL_FUNC(destroy_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "title", GTK_SIGNAL_FUNC(title_changed_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "new_window", GTK_SIGNAL_FUNC(new_window_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "visibility", GTK_SIGNAL_FUNC(visibility_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "size_to", GTK_SIGNAL_FUNC(size_to_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "location", GTK_SIGNAL_FUNC(location_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "net_start", GTK_SIGNAL_FUNC(net_start_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "net_stop", GTK_SIGNAL_FUNC(net_stop_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "net_state", GTK_SIGNAL_FUNC(net_state_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "progress", GTK_SIGNAL_FUNC(progress_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "link_message", GTK_SIGNAL_FUNC(link_message_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "js_status", GTK_SIGNAL_FUNC(js_status_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "open_uri", GTK_SIGNAL_FUNC(open_uri_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_down", GTK_SIGNAL_FUNC(dom_key_down_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_up", GTK_SIGNAL_FUNC(dom_key_up_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_down", GTK_SIGNAL_FUNC(dom_mouse_down_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_up", GTK_SIGNAL_FUNC(dom_mouse_up_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_press", GTK_SIGNAL_FUNC(dom_key_press_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_click", GTK_SIGNAL_FUNC(dom_mouse_click_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_dbl_click", GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_over", GTK_SIGNAL_FUNC(dom_mouse_over_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_out", GTK_SIGNAL_FUNC(dom_mouse_out_cb), this);
}
Unlock();
SetPosition(area.x, area.y, area.w, area.h);
SetVisible(1);
if (location) {
gtk_moz_embed_load_url(GTK_MOZ_EMBED(mozilla), location);
}
systemObject->RegisterExternalEventHandler(this);
return 0;
}
int main(int argc, char **argv)
{
GtkWidget *menubar = NULL;
GtkWidget *table = NULL;
GtkWidget *combo = NULL;
GtkBin *bin = NULL;
GtkViewport *view = NULL;
int i=0;
log_options_t lopts = LOG_OPTS_STDERR_ONLY;
if (!getenv("SLURM_BITSTR_LEN"))
setenv("SLURM_BITSTR_LEN", "128", 1); /* More array info */
slurm_conf_init(NULL);
log_init(argv[0], lopts, SYSLOG_FACILITY_USER, NULL);
load_defaults();
cluster_flags = slurmdb_setup_cluster_flags();
cluster_dims = slurmdb_setup_cluster_dims();
_init_pages();
sview_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
/* Initialize GTK */
gtk_init (&argc, &argv);
sview_mutex_new(&sview_mutex);
sview_mutex_new(&grid_mutex);
sview_cond_new(&grid_cond);
/* make sure the system is up */
grid_window = GTK_WIDGET(create_scrolled_window());
bin = GTK_BIN(>K_SCROLLED_WINDOW(grid_window)->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
main_grid_table = GTK_TABLE(bin->child);
gtk_table_set_homogeneous(main_grid_table, true);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(grid_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
/* fill in all static info for pages */
/* Make a window */
main_window = gtk_dialog_new();
g_signal_connect(G_OBJECT(main_window), "delete_event",
G_CALLBACK(_delete), NULL);
gtk_window_set_title(GTK_WINDOW(main_window), "Sview");
gtk_window_set_default_size(GTK_WINDOW(main_window),
working_sview_config.main_width,
working_sview_config.main_height);
gtk_container_set_border_width(
GTK_CONTAINER(GTK_DIALOG(main_window)->vbox), 1);
/* Create the main notebook, place the position of the tabs */
main_notebook = gtk_notebook_new();
g_signal_connect(G_OBJECT(main_notebook), "switch_page",
G_CALLBACK(_page_switched),
NULL);
table = gtk_table_new(1, 3, false);
gtk_table_set_homogeneous(GTK_TABLE(table), false);
gtk_container_set_border_width(GTK_CONTAINER(table), 1);
/* Create a menu */
menubar = _get_menubar_menu(main_window, main_notebook);
gtk_table_attach_defaults(GTK_TABLE(table), menubar, 0, 1, 0, 1);
if ((combo = _create_cluster_combo())) {
GtkWidget *label = gtk_label_new("Cluster ");
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
gtk_table_attach(GTK_TABLE(table), combo, 2, 3, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
}
gtk_notebook_popup_enable(GTK_NOTEBOOK(main_notebook));
gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_notebook), true);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_notebook),
working_sview_config.tab_pos);
main_statusbar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(main_statusbar),
false);
/* Pack it all together */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, false, false, 0);
table = gtk_table_new(1, 2, false);
gtk_table_attach(GTK_TABLE(table), grid_window, 0, 1, 0, 1,
GTK_SHRINK, GTK_EXPAND | GTK_FILL,
0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), main_notebook, 1, 2, 0, 1);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, true, true, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
main_statusbar, false, false, 0);
in_process_cursor = gdk_cursor_new(GDK_WATCH);
for(i=0; i<PAGE_CNT; i++) {
if (main_display_data[i].id == -1)
break;
create_page(GTK_NOTEBOOK(main_notebook),
&main_display_data[i]);
}
/* tell signal we are done adding */
popup_list = list_create(destroy_popup_info);
signal_params_list = list_create(destroy_signal_params);
gtk_widget_show_all(main_window);
adding = 0;
/* apply default settings */
if (!working_sview_config.show_grid)
gtk_widget_hide(grid_window);
for(i=0; i<PAGE_CNT; i++) {
GtkWidget *visible_tab = NULL;
if (main_display_data[i].id == -1)
break;
visible_tab = gtk_notebook_get_nth_page(
GTK_NOTEBOOK(main_notebook), i);
if (working_sview_config.page_visible[i]
|| (i == working_sview_config.default_page)
|| (i == TAB_PAGE))
gtk_widget_show(visible_tab);
else
gtk_widget_hide(visible_tab);
}
/* Set the default page. This has to be done after the
* gtk_widget_show_all since it, for some reason always sets
* 0 to be the default page and will just overwrite this. */
/* Also if we already are set at the current page we need to
start up the page thread, so just call the _page_switched
function. If we aren't already there, then set the current
page which will inturn call the _page_switched. If the
pages is already this the signal doesn't happen so handle
it here.
*/
if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_notebook))
== working_sview_config.default_page)
_page_switched(GTK_NOTEBOOK(main_notebook), NULL,
working_sview_config.default_page, NULL);
else
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_notebook),
working_sview_config.
default_page);
/* Finished! */
gtk_main ();
gdk_threads_leave();
return 0;
}
/*
* Windows Main
* Twitter TimeLine Cntent
*
*/
int windows_main(int argc, char **argv){
gtk_init (&argc, &argv);
char *configFile = NULL;
GError *error = NULL;
GtkWidget *window,
*table,
*scroll,
*icon_menu,
*table_into,
//*tweet,
//*avatar,
*scrolled_window,
*menu_bar,
*layout,
*toolbar,
*statusbar,
*statusbar_char,
*new_button,
*text,
*file_menu_obj,
*file_menu_root,
*file_menu_items,
*aiuto_menu_obj,
*aiuto_menu_root,
*aiuto_menu_items;
GtkTextBuffer *buffer;
asprintf(&configFile, "%s%s", g_get_home_dir(), "/.twc/config/user.twc");
/* Set all window options (color, size, position, logo, icon, etc) */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(window), 315, 650);
gtk_widget_set_size_request (window, 315, 400);
gtk_window_set_title (GTK_WINDOW(window), "TwitCrusader");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file (GTK_WINDOW(window), ICON_FAVICON, &error);
/* CALLBACK: exit event */
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
/* GTK Widget: Menu */
file_menu_obj = gtk_menu_new();
aiuto_menu_obj = gtk_menu_new();
/* SuBMenu File
* Fix Icons Linux
* gconftool-2 --type boolean --set /desktop/gnome/interface/buttons_have_icons true
* gconftool-2 --type boolean --set /desktop/gnome/interface/menus_have_icons true
* */
file_menu_items = gtk_image_menu_item_new_with_label("Nuovo Utente");
icon_menu = gtk_image_new_from_file(ICON_ADDUSER);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (windows_adduser), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_items = gtk_image_menu_item_new_with_label("Opzioni");
icon_menu = gtk_image_new_from_file(ICON_SETTINGS);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (windows_setting), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_items = gtk_image_menu_item_new_with_label("Esci");
icon_menu = gtk_image_new_from_file(ICON_CLOSE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (gtk_main_quit), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_root = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM (file_menu_root), file_menu_obj);
/* SubMenu: Help */
aiuto_menu_items = gtk_image_menu_item_new_with_label("Updates");
icon_menu = gtk_image_new_from_file(ICON_UPGRADE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (aiuto_menu_items), icon_menu);
g_signal_connect (G_OBJECT (aiuto_menu_items), "activate", G_CALLBACK (windows_upgrade), NULL);
gtk_menu_append(GTK_MENU (aiuto_menu_obj), aiuto_menu_items);
aiuto_menu_items = gtk_image_menu_item_new_with_label("Informazioni");
icon_menu = gtk_image_new_from_file(ICON_STAR);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (aiuto_menu_items), icon_menu);
g_signal_connect (G_OBJECT (aiuto_menu_items), "activate", G_CALLBACK (windows_about), NULL);
gtk_menu_append(GTK_MENU (aiuto_menu_obj), aiuto_menu_items);
aiuto_menu_root = gtk_menu_item_new_with_label("Aiuto");
gtk_menu_item_set_submenu(GTK_MENU_ITEM (aiuto_menu_root), aiuto_menu_obj);
/* Set Layout Position */
layout = gtk_vbox_new(0, 1);
gtk_container_add(GTK_CONTAINER(window), layout);
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(layout), menu_bar, FALSE, FALSE, 0);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), file_menu_root);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), aiuto_menu_root);
/* Status Bar */
statusbar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(statusbar), TRUE);
gtk_statusbar_push (GTK_STATUSBAR(statusbar), 0, "TwitCrusader...");
gtk_box_pack_end (GTK_BOX (layout), statusbar, FALSE, FALSE, 0);
/* GTK Widget: Twitter Menu */
toolbar = gtk_toolbar_new ();
gtk_box_pack_end (GTK_BOX (layout), toolbar, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
/* Twitter Menu: Buttons */
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_HOME);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_UPDATE);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_MENTION);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_DM);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_FAVORITES);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_LINK);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_PHOTO);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
/* Status Bar: Twitter 140char */
statusbar_char = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(statusbar_char), FALSE);
gtk_statusbar_push (GTK_STATUSBAR(statusbar_char), 0, "140");
gtk_box_pack_end (GTK_BOX (layout), statusbar_char, FALSE, FALSE, 0);
/* Table Content Tweet/Mentions */
table = gtk_table_new (9, 3, TRUE);
gtk_container_add(GTK_CONTAINER(layout), table);
/* Scrolled */
table_into = gtk_table_new (1, 3, TRUE);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_table_attach (GTK_TABLE (table), scrolled_window, 0, 3, 0, 8, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table_into);
/*for ( rows = 0; rows < 40; rows = rows + 4 ) {
for ( cols = 0; cols < 3; cols++ ) {
avatar = gtk_image_new_from_file ("");
tweet = gtk_label_new ("");
gtk_label_set_justify (GTK_LABEL(tweet),GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap_mode (GTK_LABEL(tweet), GTK_WRAP_WORD_CHAR);
gtk_table_attach (GTK_TABLE (table_into ), tweet, 0, 1,rows, rows + 4, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table_into ), tweet, 1, 3,rows, rows + 1, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
tweet = gtk_label_new ("");
gtk_table_attach (GTK_TABLE (table_into ), tweet, 1, 3,rows + 1, rows + 4, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
}
}*/
// TextArea + Scrollbar
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_table_attach (GTK_TABLE (table), scroll, 0, 3,8, 9, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW(text), GTK_WRAP_WORD_CHAR);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
gtk_text_buffer_set_text (buffer, "", -1);
g_signal_connect(buffer, "changed", G_CALLBACK(update_statusbar), statusbar_char);
g_signal_connect(text, "key-press-event", G_CALLBACK(send_tweet_gtk), buffer);
gtk_container_add(GTK_CONTAINER(scroll), text);
// Widget Show
gtk_widget_show_all (window);
//Exist Config File?
if(readUserFile()==1) windows_adduser();
//Show GTK Main
gtk_main ();
return 0;
}
void init_main_win( void )
{
GtkAttachOptions xOpt, yOpt;
gMapWin = gtk_window_new( GTK_WINDOW_TOPLEVEL );
if( gMapWin == NULL ){
print_msg( FLG_MSG_ERR, "gtk_window_new()" );
exit_game( EXIT_FAILURE );
}
GtkWidget *vBox = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( gMapWin ), vBox );
gtk_widget_show( vBox );
// メイン・ウィンドウへのイベント・ハンドラを設定
gtk_signal_connect( GTK_OBJECT( gMapWin ),
"delete_event",
GTK_SIGNAL_FUNC( handle_delete ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapWin ),
"destroy",
GTK_SIGNAL_FUNC( handle_destroy ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapWin ),
"key-press-event",
GTK_SIGNAL_FUNC( handleKeyPress ), NULL );
// ツール・バーを作成
GtkWidget *handleBox = gtk_handle_box_new();
gtk_box_pack_start( GTK_BOX( vBox ), handleBox, FALSE, FALSE, 0 );
gtk_widget_show( handleBox );
GtkWidget *toolBar = gtk_toolbar_new();
gtk_toolbar_set_orientation( GTK_TOOLBAR( toolBar ),
GTK_ORIENTATION_HORIZONTAL );
gtk_toolbar_set_style( GTK_TOOLBAR( toolBar ),
GTK_TOOLBAR_ICONS );
gtk_widget_show( toolBar );
gtk_container_add( GTK_CONTAINER( handleBox ), toolBar );
// ツール・バーのボタンを作成
btnMapExec = gtk_button_new_with_label(
MSG_GUI_MAP_EXEC );
gMapButtonContExec = gtk_button_new_with_label(
MSG_GUI_MAP_CONT_EXEC_OFF );
#if FLAG_BTN_MAP_LABEL_IS_NAME
btnMapAutoMark = gtk_button_new_with_label(
MSG_GUI_MAP_AUTO_MARK );
btnMapUserMenu = gtk_button_new_with_label(
MSG_GUI_MAP_USER_MENU );
btnMapSpell = gtk_button_new_with_label(
MSG_GUI_MAP_SPELL );
btnMapSquare = gtk_button_new_with_label(
MSG_GUI_MAP_SQUARE );
#else
btnMapAutoMark = gtk_button_new_with_label(
" / " );
btnMapUserMenu = gtk_button_new_with_label(
" * " );
btnMapSpell = gtk_button_new_with_label(
" - " );
btnMapSquare = gtk_button_new_with_label(
" + " );
#endif
btnMapCancel = gtk_button_new_with_label(
MSG_GUI_MAP_CANCEL );
btnMapOk = gtk_button_new_with_label(
MSG_GUI_MAP_OK );
gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ),
btnMapExec,
MSG_GUI_MAP_TOOL_TIP_EXEC,
NULL );
gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ),
gMapButtonContExec,
MSG_GUI_MAP_TOOL_TIP_CONT_EXEC,
NULL );
gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ),
btnMapAutoMark,
MSG_GUI_MAP_TOOL_TIP_AUTO_MARK,
NULL );
gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ),
btnMapUserMenu,
MSG_GUI_MAP_TOOL_TIP_USER_MENU,
NULL );
gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ),
btnMapSpell,
MSG_GUI_MAP_TOOL_TIP_SPELL,
NULL );
gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ),
btnMapSquare,
MSG_GUI_MAP_TOOL_TIP_SQUARE,
NULL );
gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ),
btnMapCancel,
MSG_GUI_MAP_TOOL_TIP_CANCEL,
NULL );
gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ),
btnMapOk,
MSG_GUI_MAP_TOOL_TIP_OK,
NULL );
gtk_widget_show( btnMapExec );
gtk_widget_show( gMapButtonContExec );
gtk_widget_show( btnMapAutoMark );
gtk_widget_show( btnMapUserMenu );
gtk_widget_show( btnMapSpell );
gtk_widget_show( btnMapSquare );
gtk_widget_show( btnMapCancel );
gtk_widget_show( btnMapOk );
// ツール・バーへのイベント・ハンドラを設定
gtk_signal_connect( GTK_OBJECT( btnMapExec ),
"clicked",
GTK_SIGNAL_FUNC( handle_exec_clicked ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapButtonContExec ),
"clicked",
GTK_SIGNAL_FUNC( handle_cont_exec_clicked ),
NULL );
gtk_signal_connect( GTK_OBJECT( btnMapAutoMark ),
"clicked",
GTK_SIGNAL_FUNC( handle_auto_mark_clicked ),
NULL );
gtk_signal_connect( GTK_OBJECT( btnMapUserMenu ),
"clicked",
GTK_SIGNAL_FUNC( handle_user_menu_clicked ),
NULL );
gtk_signal_connect( GTK_OBJECT( btnMapSpell ),
"clicked",
GTK_SIGNAL_FUNC( handle_spell_clicked ),
NULL );
gtk_signal_connect( GTK_OBJECT( btnMapSquare ),
"clicked",
GTK_SIGNAL_FUNC( handle_square_clicked ),
NULL );
gtk_signal_connect( GTK_OBJECT( btnMapCancel ),
"clicked",
GTK_SIGNAL_FUNC( handle_cancel_clicked ),
NULL );
gtk_signal_connect( GTK_OBJECT( btnMapOk ),
"clicked",
GTK_SIGNAL_FUNC( handle_ok_clicked ),
NULL );
// 描画エリアを作成
GtkWidget *pTab = gtk_table_new( 2, 2, FALSE );
gtk_box_pack_start( GTK_BOX( vBox ), pTab, TRUE, TRUE, 0 );
gtk_widget_show( pTab );
gMapDrawingArea = gtk_drawing_area_new();
if( gMapDrawingArea == NULL ){
print_msg( FLG_MSG_ERR, "gtk_drawing_area_new()" );
exit_game( EXIT_FAILURE );
}
gtk_drawing_area_size( GTK_DRAWING_AREA( gMapDrawingArea ),
MAP_WIN_INIT_WIDTH(),
MAP_WIN_INIT_HEIGHT() );
xOpt = (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL);
yOpt = (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL);
gtk_table_attach( GTK_TABLE( pTab ), gMapDrawingArea,
0, 1, 0, 1,
xOpt, yOpt,
0, 0 );
gtk_widget_show( gMapDrawingArea );
// 描画エリアへのイベント・ハンドラを設定
gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ),
"expose_event",
GTK_SIGNAL_FUNC( handle_map_expose ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ),
"configure_event",
GTK_SIGNAL_FUNC( handle_map_configure ),
NULL );
// 描画エリアのマウス・モーションのイベント・ハンドラを設定
gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ),
"motion_notify_event",
GTK_SIGNAL_FUNC( handle_map_motion_notify ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ),
"button_press_event",
GTK_SIGNAL_FUNC( handle_map_button_press ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ),
"button_release_event",
GTK_SIGNAL_FUNC( handle_map_button_release ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ),
"scroll_event",
GTK_SIGNAL_FUNC( handle_map_scroll ),
NULL );
gtk_widget_set_events(
gMapDrawingArea,
(GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_SCROLL_MASK) );
// 水平スクロール・バーの調整を作成
gMapHScrollBarAdjustment = gtk_adjustment_new(
0,
0, MAP_PIX_MAX_X(),
1 * TILE_X_SIZE(),
AREA_MAX_X * TILE_X_SIZE() / 2,
AREA_MAX_X * TILE_X_SIZE() );
if( gMapHScrollBarAdjustment == NULL ){
print_msg( FLG_MSG_ERR, "gtk_adjustment_new()" );
exit_game( EXIT_FAILURE );
}
// 水平スクロール・バーの調整のイベント・ハンドラを設定
gtk_signal_connect( GTK_OBJECT( gMapHScrollBarAdjustment ),
"changed",
GTK_SIGNAL_FUNC( handle_map_scroll_changed ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapHScrollBarAdjustment ),
"value_changed",
GTK_SIGNAL_FUNC( handle_map_scroll_changed ),
NULL );
// 水平スクロール・バーを作成
gMapHScrollBar = gtk_hscrollbar_new(
GTK_ADJUSTMENT( gMapHScrollBarAdjustment ) );
if( gMapHScrollBar == NULL ){
print_msg( FLG_MSG_ERR, "gtk_hscrollbar_new()" );
exit_game( EXIT_FAILURE );
}
xOpt = (GtkAttachOptions)(GTK_SHRINK | GTK_FILL);
yOpt = (GtkAttachOptions)(GTK_FILL);
gtk_table_attach( GTK_TABLE( pTab ),
gMapHScrollBar,
0, 1, 1, 2,
xOpt, yOpt,
0, 0 );
gtk_widget_show( gMapHScrollBar );
// 垂直スクロール・バーの調整を作成
gMapVScrollBarAdjustment = gtk_adjustment_new(
0,
0, MAP_PIX_MAX_Y(),
1 * TILE_Y_SIZE(),
AREA_MAX_Y * TILE_Y_SIZE() / 2,
AREA_MAX_Y * TILE_Y_SIZE() );
if( gMapVScrollBarAdjustment == NULL ){
print_msg( FLG_MSG_ERR, "gtk_adjustment_new()" );
exit_game( EXIT_FAILURE );
}
// 垂直スクロール・バーの調整のイベント・ハンドラを設定
gtk_signal_connect( GTK_OBJECT( gMapVScrollBarAdjustment ),
"changed",
GTK_SIGNAL_FUNC( handle_map_scroll_changed ),
NULL );
gtk_signal_connect( GTK_OBJECT( gMapVScrollBarAdjustment ),
"value_changed",
GTK_SIGNAL_FUNC( handle_map_scroll_changed ),
NULL );
// 垂直スクロール・バーを作成
gMapVScrollBar = gtk_vscrollbar_new(
GTK_ADJUSTMENT( gMapVScrollBarAdjustment ) );
if( gMapVScrollBar == NULL ){
print_msg( FLG_MSG_ERR, "gtk_vscrollbar_new()" );
exit_game( EXIT_FAILURE );
}
xOpt = (GtkAttachOptions)(GTK_FILL);
yOpt = (GtkAttachOptions)(GTK_SHRINK | GTK_FILL);
gtk_table_attach( GTK_TABLE( pTab ),
gMapVScrollBar,
1, 2, 0, 1,
xOpt, yOpt,
0, 0 );
gtk_widget_show( gMapVScrollBar );
// ステータス・バーを作成
statBarMap = gtk_statusbar_new();
if( statBarMap == NULL ){
print_msg( FLG_MSG_ERR, "gtk_statusbar_new()" );
exit_game( EXIT_FAILURE );
}
gtk_box_pack_start( GTK_BOX( vBox ), statBarMap, FALSE, FALSE, 0 );
statBarMapContextId = gtk_statusbar_get_context_id(
GTK_STATUSBAR( statBarMap ), "Status bar" );
gtk_statusbar_set_has_resize_grip(
GTK_STATUSBAR( statBarMap ), TRUE );
statBarMapMesId = gtk_statusbar_push(
GTK_STATUSBAR( statBarMap ),
statBarMapContextId, "OK" );
gtk_widget_show( statBarMap );
// メイン・ウィンドウを表示
gWinPos[WIN_KIND_MAP].draw( WIN_KIND_MAP );
gtk_drawing_area_size( GTK_DRAWING_AREA( gMapDrawingArea ),
MAP_WIN_MIN_WIDTH(),
MAP_WIN_MIN_HEIGHT() );
}
