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() ); }