/* Map G_LOG_LEVEL_INFO logs to the window's status bar. */ static void ui_log_level_info (const gchar * log_domain, GLogLevelFlags log_level, const char * message, gpointer user_data) { static GtkWidget * statusbar; static guint context; static guint initialized = 0; if (!initialized) { statusbar = GET_OBJECT ("statusbar"); context = gtk_statusbar_get_context_id(GTK_STATUSBAR (statusbar), "Game messages"); initialized = 1; } gtk_statusbar_pop (GTK_STATUSBAR (statusbar), context); gtk_statusbar_push (GTK_STATUSBAR (statusbar), context, message); gtk_main_iteration(); }
void say (char *fmt, ...) { va_list ap; char buf[200]; guint context_id; if (test_computer_play > 0) return; va_start (ap, fmt); g_vsnprintf (buf, 200, fmt, ap); va_end (ap); context_id = gtk_statusbar_get_context_id (GTK_STATUSBAR (statusbar), "message"); gtk_statusbar_pop (GTK_STATUSBAR (statusbar), context_id); gtk_statusbar_push (GTK_STATUSBAR (statusbar), context_id, buf); }
static void selection_changed (Diagram* dia, int n, DDisplay* ddisp) { GtkStatusbar *statusbar; guint context_id; /* nothing to do if there is no display with the diagram anymore */ if (g_slist_length(dia->displays) < 1) return; statusbar = GTK_STATUSBAR (ddisp->modified_status); context_id = gtk_statusbar_get_context_id (statusbar, "Selection"); if (n > 1) { gchar *msg; /* http://www.gnu.org/software/gettext/manual/html_chapter/gettext_10.html#SEC150 * Althoug the single objects wont get triggered here some languages have variations on the other numbers */ msg = g_strdup_printf (ngettext ("Selection of %d object", "Selection of %d objects", n), n); gtk_statusbar_pop (statusbar, context_id); gtk_statusbar_push (statusbar, context_id, msg); g_free (msg); } else if (n == 1) { /* find the selected objects name - and display it */ DiaObject *object = (DiaObject *)ddisp->diagram->data->selected->data; gchar *name = object_get_displayname (object); gchar *msg = g_strdup_printf (_("Selected '%s'"), name); gtk_statusbar_pop (statusbar, context_id); gtk_statusbar_push (statusbar, context_id, msg); g_free (name); g_free (msg); } else { gtk_statusbar_pop (statusbar, context_id); } /* selection-changed signal can also be emitted from outside of the dia core */ ddisplay_do_update_menu_sensitivity (ddisp); }
void statusbar_puts(GtkStatusbar *statusbar, const gchar *str) { gint cid; gchar *buf; gchar *tmp; tmp = g_strdup(str); strretchomp(tmp); buf = trim_string(tmp, 76); g_free(tmp); cid = gtk_statusbar_get_context_id(statusbar, "Standard Output"); gtk_statusbar_pop(statusbar, cid); gtk_statusbar_push(statusbar, cid, buf); gtkut_widget_draw_now(GTK_WIDGET(statusbar)); g_free(buf); }
static GtkWidget * dcc_gnome_make_load_bar (void) { GtkWidget *bar; gint context_id; bar = gtk_statusbar_new (); context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR (bar), "load"); gtk_statusbar_push(GTK_STATUSBAR (bar), context_id, "Load: "); g_timeout_add (2000, /* ms */ dcc_gnome_load_update_cb, bar); dcc_gnome_load_update_cb (bar); return bar; }
void game_message(const char *format, ...) { int id; va_list ap; char *message; GtkWidget *status; va_start(ap, format); message = g_strdup_vprintf(format, ap); va_end(ap); status = lookup_widget(main_win, "statusbar"); id = gtk_statusbar_get_context_id(GTK_STATUSBAR(status), "Main"); gtk_statusbar_pop(GTK_STATUSBAR(status), id); gtk_statusbar_push(GTK_STATUSBAR(status), id, message); g_free(message); }
orcaData orcaGtk::ex_set_text(orcaVM* vm, int n)/*{{{*/ { if (n < 1) vm->need_param(); string str = vm->get_param(0).string_(vm); switch(type) { case GUI_WINDOW: gtk_window_set_title(GTK_WINDOW(handle), str.c_str()); break; case GUI_BUTTON: case GUI_CHECK: case GUI_RADIO: gtk_button_set_label(GTK_BUTTON(handle), str.c_str()); break; case GUI_LABEL: gtk_label_set_text(GTK_LABEL(handle), str.c_str()); break; case GUI_TEXT: { GtkTextBuffer *buffer; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(handle)); gtk_text_buffer_set_text(buffer, str.c_str(), -1); break; } case GUI_STATUSBAR: gtk_statusbar_push(GTK_STATUSBAR(handle), gtk_statusbar_get_context_id(GTK_STATUSBAR(handle), str.c_str()), str.c_str()); break; case GUI_ENTRY: gtk_entry_set_text(GTK_ENTRY(handle), str.c_str()); break; } text = str; return NIL; }
static void profile_bar_new(void) { GtkTooltips *tooltips; tooltips = gtk_tooltips_new(); 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); profile_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(profile_bar), "profile"); gtk_tooltips_set_tip (tooltips, profile_bar_event, "Click to change configuration profile", NULL); profile_bar_update(); gtk_widget_show(profile_bar); gtk_widget_show(profile_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); }
/* Helper function for uistatus() */ static gboolean realstatus(gpointer data) { GtkStatusbar* sb = GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar")); GtkSpinner* spinner = GTK_SPINNER(gtk_builder_get_object(builder, "busy_spinner")); struct statusupdate *update = (struct statusupdate*)data; if(G_UNLIKELY(!statusbar_context)) { statusbar_context = gtk_statusbar_get_context_id(sb, "useless"); } gtk_statusbar_remove_all(sb, statusbar_context); gtk_widget_set_visible(GTK_WIDGET(spinner), update->spin); g_object_set(G_OBJECT(spinner), "active", update->spin, NULL); if(update->text) { gtk_statusbar_push(sb, statusbar_context, update->text); g_free(update->text); } g_free(update); return FALSE; }
static void menu_item_select_cb (GtkWidget * widget, GtkStatusbar * statusbar) { GtkAction *action; gchar *tooltip; guint context_id; context_id = gtk_statusbar_get_context_id (statusbar, "games-tooltip"); action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (widget)); g_return_if_fail (action != NULL); g_object_get (action, "tooltip", &tooltip, NULL); if (tooltip) { gtk_statusbar_push (statusbar, context_id, tooltip); g_free (tooltip); } }
static GGZHookReturn ggz_num_players_changed(GGZServerEvent id, const void *event_data, const void *user_data) { GtkWidget *serverbar = ggz_lookup_widget(ggz_gtk.win_main, "serverbar"); guint context; int players = ggzcore_server_get_num_players(ggz_gtk.server); char *buf; buf = g_strdup_printf(_("Players on server: %d"), players); context = gtk_statusbar_get_context_id(GTK_STATUSBAR(serverbar), "players"); gtk_statusbar_pop(GTK_STATUSBAR(serverbar), context); gtk_statusbar_push(GTK_STATUSBAR(serverbar), context, buf); g_free(buf); return GGZ_HOOK_OK; }
create_statusbar ()void *GtkMain(void * argument) { printf("%s:%d\n", __func__, __LINE__); int argc = 0; char**argv = NULL; unsigned char haveUrl = 0; int argCount = 0; { g_main_statusbar = GTK_STATUSBAR (gtk_statusbar_new ()); gtk_widget_set_can_focus(GTK_WIDGET (g_main_statusbar), false); status_context_id = gtk_statusbar_get_context_id (g_main_statusbar, "Link Hover"); return (GtkWidget*)g_main_statusbar; } static GtkWidget* create_toolbar () { g_toolbar = gtk_toolbar_new (); gtk_widget_set_can_focus(GTK_WIDGET (g_toolbar), false); #if GTK_CHECK_VERSION(2,15,0) gtk_orientable_set_orientation (GTK_ORIENTABLE (g_toolbar), GTK_ORIENTATION_HORIZONTAL); #else gtk_toolbar_set_orientation (GTK_TOOLBAR (g_toolbar), GTK_ORIENTATION_HORIZONTAL); #endif gtk_toolbar_set_style (GTK_TOOLBAR (g_toolbar), GTK_TOOLBAR_BOTH_HORIZ); /* The URL entry */ itemUrl = gtk_tool_item_new (); gtk_widget_set_can_focus(GTK_WIDGET (itemUrl), false); gtk_tool_item_set_expand (itemUrl, TRUE); uri_entry = gtk_entry_new (); gtk_container_add (GTK_CONTAINER (itemUrl), uri_entry); g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (g_toolbar), itemUrl, -1); return g_toolbar; }
static gboolean status_bar_refresh(gpointer data) { gdk_threads_enter(); if (balsa_app.main_window) { GtkStatusbar *statusbar; guint context_id; statusbar = GTK_STATUSBAR(balsa_app.main_window->statusbar); context_id = gtk_statusbar_get_context_id(statusbar, "Information bar"); gtk_statusbar_pop(statusbar, context_id); } bar_timeout_id = 0; gdk_threads_leave(); return FALSE; }
static void widget_statusbar_update(variable *var, gchar *text) { guint context_id; #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Entering.\n", __func__); #endif /* A context ID is required to push and pop the messages */ context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(var->Widget), "General"); gtk_statusbar_pop(GTK_STATUSBAR(var->Widget), context_id); gtk_statusbar_push(GTK_STATUSBAR(var->Widget), context_id, text); g_object_set_data(G_OBJECT(var->Widget), "_last_push", g_strdup(text)); #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Exiting.\n", __func__); #endif }
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 set_status(char const * format, ...) { va_list ap; guint id; gchar *status; va_start(ap, format); if (vnc != NULL) { id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), ""); status = g_strdup_vprintf(format, ap); gtk_statusbar_pop(GTK_STATUSBAR(statusbar), id); gtk_statusbar_push(GTK_STATUSBAR(statusbar), id, status); g_free(status); } else { fputs(PROGNAME ": ", stderr); vfprintf(stderr, format, ap); fputc('\n', stderr); } va_end(ap); }
static void hovering_over_link (WebKitWebView *web_view, const gchar *title, const gchar *uri, gpointer user_data) { MarinaWindow *window; static guint cid = 0; g_return_if_fail (WEBKIT_IS_WEB_VIEW (web_view)); window = MARINA_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (web_view))); if (!cid) cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (window->priv->statusbar), "html-link"); gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar), cid); if (uri) gtk_statusbar_push (GTK_STATUSBAR (window->priv->statusbar), cid, uri); }
static void test_grf_imagewidget_show(void**state){ (void) state; gtk_init(NULL, NULL); pressed = 0; char* filenames[3] = {"../data/trekkie-nerdbw.png", // Gray "../data/distance_transform_input.pgm", // Gray "../data/trekkie-nerd.jpg"}; // Color GrfArray* array_gray = grf_image_read(filenames[0]); GtkWidget* imagewidget = grf_imagewidget_new(); GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); lbl_color = gtk_label_new(""); statusbar = gtk_statusbar_new(); context = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar),"example"); gtk_widget_set_size_request(statusbar,-1,30); gtk_widget_add_events(imagewidget, GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK); gtk_widget_add_events(imagewidget,GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK); grf_imagewidget_set_image(GRF_IMAGEWIDGET(imagewidget),array_gray, TRUE); gtk_box_pack_start (GTK_BOX(box),imagewidget,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX(box),statusbar,FALSE,TRUE,0); gtk_box_pack_end(GTK_BOX(statusbar),lbl_color,FALSE,FALSE,0); gtk_container_add (GTK_CONTAINER(window), box); // Mouse events g_signal_connect (imagewidget, "button-press-event" , G_CALLBACK(helper_test_imagewidget_press_event), NULL); g_signal_connect (imagewidget, "button-release-event", G_CALLBACK(helper_test_imagewidget_release_event) , NULL); g_signal_connect (imagewidget, "motion-notify-event" , G_CALLBACK(helper_test_imagewidget_move_event) , array_gray); g_signal_connect (imagewidget, "scroll-event" , G_CALLBACK(helper_test_imagewidget_scroll_event) , NULL); // Keyboard events g_signal_connect (imagewidget, "key-press-event" , G_CALLBACK(window_key_press_event), NULL); g_signal_connect (imagewidget, "key-release-event" , G_CALLBACK(window_key_release_event), NULL); // Other events g_signal_connect (window , "destroy" , G_CALLBACK(gtk_main_quit),NULL); // Show window gtk_widget_show_all(window); gtk_main(); }
void ui_init() { GtkWidget *window = NULL; GtkBuilder *builder; GError *err = NULL; gchar *exec_name = NULL; gchar *tmp = NULL; gchar exe_path[MAX_PATH]; GtkEntry *entry; gtk_init(NULL, NULL); builder = gtk_builder_new(); exec_name = g_file_read_link("/proc/self/exe", NULL); tmp = g_strrstr(exec_name, "/"); *tmp = 0; g_strlcpy(exe_path, exec_name, MAX_PATH); g_strlcat(exe_path, "/audio_player.glade", MAX_PATH); g_free(exec_name); gtk_builder_add_from_file(builder, exe_path, &err); gtk_builder_connect_signals(builder, NULL); window = GTK_WIDGET(gtk_builder_get_object(builder, "main_window")); main_window_sub_widget.statusbar = GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar1")); main_window_sub_widget.contextId = gtk_statusbar_get_context_id( GTK_STATUSBAR(main_window_sub_widget.statusbar), "Editor Messages"); entry = GTK_ENTRY(gtk_builder_get_object(builder, "entry1")); main_window_sub_widget.entry1 = entry; g_signal_connect(window, "destroy", G_CALLBACK (gtk_main_quit), &window); g_object_unref(G_OBJECT(builder)); gtk_widget_show_all(window); }
/** * gwy_statusbar_set_markup: * @statusbar: A statusbar. * @markup: Text message to display in the statusbar. It can contain Pango * markup. * * Sets the text to display in a status bar. * * This method is intended for simple status bars that do not have stacks and * do not need contexts. It does not mix with gtk_status_bar_push(). You can * use either this simple interface or the full stacks-and-contexts API with * #GwyStatusbar, but not both in the same status bar. **/ void gwy_statusbar_set_markup(GwyStatusbar *statusbar, const gchar *markup) { GtkStatusbar *sbar; guint id; sbar = GTK_STATUSBAR(statusbar); if (!statusbar->context_id) { if (sbar->keys) g_warning("gwy_statusbar_set_markup() does not mix with " "full stacks-and-context GwyStatusbar API"); statusbar->context_id = gtk_statusbar_get_context_id(sbar, "GwyStatusbar-global-context"); } id = gtk_statusbar_push(sbar, statusbar->context_id, markup); if (statusbar->message_id) gtk_statusbar_remove(sbar, statusbar->context_id, statusbar->message_id); statusbar->message_id = id; }
void parts_enter_button_clicked(GtkWidget *widget, GrmGui *gui) { /* face node data push to stack flow * * 1 drawingarea1 clicked by leftbutton * 2 get coordinate and set to gui (drawingarea1_clicked()) * 3 if gui->tmp_node_data and gui->face_node_data is NULL * get memory and initialize them (set_clicked_point_data_drawarea_clicked()) * 4 when parts_button clicked, gui->tmp_node_data memcpy to * same button's parts_name gui->face_node_data[n] (parts_button_clicked()) * 5 when enter button clicked, gui->face_node_data addressing data move to stack * and new memory give for gui->face_node_data; (parts_enter_button_clicked(), here!) * 6 goto 1 or 4(sometime) */ gaborrg_maker_face_node_data_stack_push(&gui->face_node_data_stack, gui->face_node_data); gui->face_node_data= gaborrg_maker_face_node_data_new_from_gui(gui); /* indicator and messages */ { gaborrg_maker_all_parts_buttons_indicator_appear_or_not(gui,0); gchar* message= "all parts data save to buffer. restart click on drawarea by right button"; guint context_id= gtk_statusbar_get_context_id( GTK_STATUSBAR(gui->statusbar1), "parts_enter_button message"); gtk_statusbar_push( GTK_STATUSBAR(gui->statusbar1),context_id,message); g_print("parts_enter_button_clicked!\n"); } return; }
static gint dcc_gnome_load_update_cb (gpointer data) { gchar message[200]; double loadavg[3]; guint context_id; if (getloadavg (loadavg, 3) == -1) { rs_log_error ("getloadavg failed: %s", strerror (errno)); return FALSE; /* give up */ } snprintf (message, sizeof message, "Load average: %.2f, %.2f, %.2f", loadavg[0], loadavg[1], loadavg[2]); context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR (data), "load"); gtk_statusbar_pop(GTK_STATUSBAR (data), context_id); gtk_statusbar_push(GTK_STATUSBAR (data), context_id, message); return TRUE; /* please call again */ }
void statusbar_init(GUIData *ltrgui) { GtkWidget *hbox; gchar msg[BUFSIZ]; gint id; ltrgui->statusbar = gtk_statusbar_new(); ltrgui->progressbar = gtk_progress_bar_new(); hbox = gtk_hbox_new(TRUE, 1); gtk_box_pack_start(GTK_BOX(hbox), ltrgui->statusbar, FALSE, TRUE, 1); gtk_box_pack_start(GTK_BOX(hbox), ltrgui->progressbar, TRUE, TRUE, 1); gtk_widget_show_all(hbox); id = gtk_statusbar_get_context_id(GTK_STATUSBAR(ltrgui->statusbar), STATUSBAR_CONTEXT); ltrgui->statusbar_context_id = id; g_snprintf(msg, BUFSIZ, STATUSBAR_MSG_WELCOME, GUI_NAME); gtk_statusbar_push(GTK_STATUSBAR(ltrgui->statusbar), ltrgui->statusbar_context_id, msg); gtk_box_pack_end(GTK_BOX(ltrgui->vbox), hbox, FALSE, FALSE, 0); }
static void gedit_spell_plugin_activate (GeditWindowActivatable *activatable) { GeditSpellPlugin *plugin; GeditSpellPluginPrivate *priv; GList *views, *l; gedit_debug (DEBUG_PLUGINS); plugin = GEDIT_SPELL_PLUGIN (activatable); priv = plugin->priv; g_action_map_add_action_entries (G_ACTION_MAP (priv->window), action_entries, G_N_ELEMENTS (action_entries), activatable); priv->message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (gedit_window_get_statusbar (priv->window)), "spell_plugin_message"); update_ui (plugin); views = gedit_window_get_views (priv->window); for (l = views; l != NULL; l = g_list_next (l)) { GeditView *view = GEDIT_VIEW (l->data); set_auto_spell_from_metadata (plugin, view); } priv->tab_added_id = g_signal_connect (priv->window, "tab-added", G_CALLBACK (tab_added_cb), activatable); priv->tab_removed_id = g_signal_connect (priv->window, "tab-removed", G_CALLBACK (tab_removed_cb), activatable); }
GtkWidget *widget_statusbar_create( AttributeSet *Attr, tag_attr *attr, gint Type) { GtkWidget *widget; guint context_id; #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Entering.\n", __func__); #endif widget = gtk_statusbar_new(); /* A context ID is required to push and pop the messages */ context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(widget), "General"); #ifdef DEBUG_CONTENT fprintf(stderr, "%s(): context_id=%i\n", __func__, context_id); #endif /* Push an initial empty message and from hereon in, everytime a * new message is set we will first pop the existing message and * then push the new one */ gtk_statusbar_push(GTK_STATUSBAR(widget), context_id, ""); /* Record the current message because otherwise it'll have to be * dug out from the label inside the box that is the statusbar */ g_object_set_data(G_OBJECT(widget), "_last_push", g_strdup("")); #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Exiting.\n", __func__); #endif return widget; }
void game_status(const char *format, ...) { int id; va_list ap; char *message; gpointer tmp; va_start(ap, format); message = g_strdup_vprintf(format, ap); va_end(ap); /* ggz_debug("main", "Game status message: %s", message); */ tmp = g_object_get_data(G_OBJECT(main_win), "statusbar"); id = gtk_statusbar_get_context_id(GTK_STATUSBAR(tmp), "Main"); gtk_statusbar_pop(GTK_STATUSBAR(tmp), id); gtk_statusbar_push(GTK_STATUSBAR(tmp), id, message); g_free(message); }
/** * Create main dialog decorations (excluding notebook pages). */ static void export_ldif_dialog_create( void ) { GtkWidget *window; GtkWidget *vbox; GtkWidget *vnbox; GtkWidget *notebook; GtkWidget *hbbox; GtkWidget *btnPrev; GtkWidget *btnNext; GtkWidget *btnCancel; GtkWidget *hsbox; GtkWidget *statusbar; window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "expldifdlg"); gtk_widget_set_size_request(window, EXPORTLDIF_WIDTH, EXPORTLDIF_HEIGHT ); gtk_container_set_border_width( GTK_CONTAINER(window), 0 ); gtk_window_set_title( GTK_WINDOW(window), _("Export Address Book to LDIF File") ); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(export_ldif_delete_event), NULL ); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(export_ldif_key_pressed), NULL ); vbox = gtk_vbox_new(FALSE, 4); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(window), vbox); vnbox = gtk_vbox_new(FALSE, 4); gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4); gtk_widget_show(vnbox); gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0); /* Notebook */ notebook = gtk_notebook_new(); gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), FALSE ); /* Hide */ /* gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), TRUE ); */ gtk_widget_show(notebook); gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(notebook), 6); /* Status line */ hsbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH); statusbar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH); /* Button panel */ gtkut_stock_button_set_create(&hbbox, &btnPrev, GTK_STOCK_GO_BACK, &btnNext, GTK_STOCK_GO_FORWARD, &btnCancel, GTK_STOCK_CANCEL); gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbbox), 2); gtk_widget_grab_default(btnNext); /* Button handlers */ g_signal_connect(G_OBJECT(btnPrev), "clicked", G_CALLBACK(export_ldif_prev), NULL); g_signal_connect(G_OBJECT(btnNext), "clicked", G_CALLBACK(export_ldif_next), NULL); g_signal_connect(G_OBJECT(btnCancel), "clicked", G_CALLBACK(export_ldif_cancel), NULL); gtk_widget_show_all(vbox); expldif_dlg.window = window; expldif_dlg.notebook = notebook; expldif_dlg.btnPrev = btnPrev; expldif_dlg.btnNext = btnNext; expldif_dlg.btnCancel = btnCancel; expldif_dlg.statusbar = statusbar; expldif_dlg.status_cid = gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "Export LDIF Dialog" ); }
MessageView *messageview_create_with_new_window(void) { MessageView *msgview; GtkWidget *window; GtkWidget *window_vbox; GtkWidget *body_vbox; GtkWidget *vspacer; GtkWidget *menubar; GtkItemFactory *ifactory; GtkWidget *statusbar; guint n_menu_entries; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), _("Message View - Sylpheed")); gtk_window_set_wmclass(GTK_WINDOW(window), "message_view", "Sylpheed"); gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, FALSE); gtk_widget_set_size_request(window, prefs_common.msgwin_width, prefs_common.msgwin_height); msgview = messageview_create(); window_vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), window_vbox); g_signal_connect(G_OBJECT(window), "size_allocate", G_CALLBACK(messageview_size_allocate_cb), msgview); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(messageview_delete_cb), msgview); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(key_pressed), msgview); MANAGE_WINDOW_SIGNALS_CONNECT(window); n_menu_entries = sizeof(msgview_entries) / sizeof (msgview_entries[0]); menubar = menubar_create(window, msgview_entries, n_menu_entries, "<MessageView>", msgview); #if 0 menu_factory_copy_rc("<Main>", "<MessageView>"); #endif gtk_box_pack_start(GTK_BOX(window_vbox), menubar, FALSE, TRUE, 0); vspacer = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(window_vbox), vspacer, FALSE, TRUE, BORDER_WIDTH); body_vbox = gtk_vbox_new(FALSE, BORDER_WIDTH); gtk_box_pack_start(GTK_BOX(window_vbox), body_vbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(body_vbox), GTK_WIDGET_PTR(msgview), TRUE, TRUE, 0); gtk_widget_grab_focus(msgview->textview->text); statusbar = gtk_statusbar_new(); gtk_box_pack_end(GTK_BOX(body_vbox), statusbar, FALSE, FALSE, 0); msgview->statusbar = statusbar; msgview->statusbar_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR(statusbar), "Message View"); msgview->new_window = TRUE; msgview->window = window; msgview->window_vbox = window_vbox; msgview->body_vbox = body_vbox; msgview->menubar = menubar; msgview->menu_locked = FALSE; msgview->visible = TRUE; gtk_widget_show_all(window); messageview_init(msgview); messageview_set_encoding_menu(msgview); ifactory = gtk_item_factory_from_widget(menubar); #ifndef G_OS_WIN32 action_update_msgview_menu(ifactory, msgview); #endif messageview_list = g_list_append(messageview_list, msgview); return msgview; }
int main (int argc, char *argv[]) { int i; const char *commandLine_File = NULL; GtkWidget *pVBox; GtkWidget *pMenuBar; GtkWidget *pMenu, *pSubMenu; GtkWidget *pMenuItem, *pSubMenuItem; GtkAccelGroup * accel_group; if(argc == 2) commandLine_File = argv[1]; #ifdef DEBUG LogStart(); #endif gtk_init(&argc, &argv); SDL_Init(SDL_INIT_VIDEO); desmume_init(); dTools_running = (BOOL*)malloc(sizeof(BOOL) * dTools_list_size); for(i=0; i<dTools_list_size; i++) dTools_running[i]=FALSE; CONFIG_FILE = g_build_filename(g_get_home_dir(), ".desmume.ini", NULL); Read_ConfigFile(); /* Creation de la fenetre */ pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(pWindow), "Desmume"); gtk_window_set_policy (GTK_WINDOW (pWindow), FALSE, FALSE, FALSE); gtk_window_set_icon(GTK_WINDOW (pWindow), gdk_pixbuf_new_from_xpm_data(DeSmuME_xpm)); g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(pWindow), "key_press_event", G_CALLBACK(Key_Press), NULL); g_signal_connect(G_OBJECT(pWindow), "key_release_event", G_CALLBACK(Key_Release), NULL); /* Creation de la GtkVBox */ pVBox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(pWindow), pVBox); accel_group = gtk_accel_group_new(); action_group = gtk_action_group_new("dui"); gtk_action_group_add_actions(action_group, action_entries, sizeof(action_entries) / sizeof(GtkActionEntry), pWindow); { GList * list = gtk_action_group_list_actions(action_group); g_list_foreach(list, dui_set_accel_group, accel_group); } gtk_window_add_accel_group(GTK_WINDOW(pWindow), accel_group); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "pause"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "run"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "reset"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "printscreen"), FALSE); /**** Creation du menu ****/ pMenuBar = gtk_menu_bar_new(); /** Menu "Fichier" **/ pMenu = gtk_menu_new(); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "open"))); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "printscreen"))); gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "quit"))); pMenuItem = gtk_menu_item_new_with_label("File"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /** Menu "Emulation" **/ GtkWidget *mEmulation; GtkWidget *mFrameskip; GtkWidget *mFrameskip_Radio[MAX_FRAMESKIP]; GtkWidget *mGraphics; GtkWidget *mSize; GtkWidget *mSize_Radio[MAX_SCREENCOEFF]; GtkWidget *mLayers; GtkWidget *mLayers_Radio[10]; mEmulation = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Emulation"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mEmulation); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "run"))); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "pause"))); gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "reset"))); mFrameskip = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Frameskip"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFrameskip); gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem); for(i = 0; i < MAX_FRAMESKIP; i++) { char frameskipRadio_buf[16]; sprintf(frameskipRadio_buf, "%d", i); if(i>0) mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mFrameskip_Radio[i-1]), frameskipRadio_buf); else mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, frameskipRadio_buf); g_signal_connect(G_OBJECT(mFrameskip_Radio[i]), "activate", G_CALLBACK(Modify_Frameskip), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(mFrameskip), mFrameskip_Radio[i]); } gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE); mGraphics = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Graphics"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mGraphics); gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem); // TODO: Un jour, peut être... >< mSize = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Size"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mSize); gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem); for(i = 1; i < MAX_SCREENCOEFF; i++) { char sizeRadio_buf[16]; sprintf(sizeRadio_buf, "x%d", i); if(i>1) mSize_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mSize_Radio[i-1]), sizeRadio_buf); else mSize_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, sizeRadio_buf); g_signal_connect(G_OBJECT(mSize_Radio[i]), "activate", G_CALLBACK(Modify_ScreenCoeff), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(mSize), mSize_Radio[i]); } gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE); mLayers = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Layers"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mLayers); gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem); for(i = 0; i < 10; i++) { mLayers_Radio[i] = gtk_check_menu_item_new_with_label(Layers_Menu[i]); g_signal_connect(G_OBJECT(mLayers_Radio[i]), "activate", G_CALLBACK(Modify_Layer), (void*)Layers_Menu[i]); gtk_menu_shell_append(GTK_MENU_SHELL(mLayers), mLayers_Radio[i]); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mLayers_Radio[i]), TRUE); } /** Menu "Options" **/ GtkWidget *mConfig = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Config"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Edit controls"); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Edit_Controls), (GtkWidget*) pWindow); gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem); #if 0 GtkWidget *mFirmware; mFirmware = gtk_menu_new(); pMenuItem = gtk_menu_item_new_with_label("Firmware"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFirmware); gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Select..."); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(SelectFirmwareFile), (gpointer)0); gtk_menu_shell_append(GTK_MENU_SHELL(mFirmware), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("Config"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); #endif /** Menu "Outils" **/ pMenu = gtk_menu_new(); for(i = 0; i < dTools_list_size; i++) { pMenuItem = gtk_menu_item_new_with_label(dTools_list[i]->name); g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Start_dTool), GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem); } pMenuItem = gtk_menu_item_new_with_label("Tools"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /** Menu "?" **/ pMenu = gtk_menu_new(); #if ((GTK_MAJOR_VERSION >= 2) && (GTK_MINOR_VERSION >= 6)) pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL); #else pMenuItem = gtk_menu_item_new_with_label("About"); #endif g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(About), (GtkWidget*) pWindow); gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem); pMenuItem = gtk_menu_item_new_with_label("?"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu); gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem); /* Ajout du menu a la fenetre */ gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0); /* Création de la Toolbar */ pToolbar = gtk_toolbar_new(); gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "open"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "run"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "pause"))), -1); gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "quit"))), -1); /* Création de l'endroit pour l'affichage des écrans */ pDrawingArea= gtk_drawing_area_new(); gtk_drawing_area_size(GTK_DRAWING_AREA(pDrawingArea), 256, 384); gtk_widget_set_usize (pDrawingArea, 256, 384); gtk_widget_set_events(pDrawingArea, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK ); g_signal_connect(G_OBJECT(pDrawingArea), "button_press_event", G_CALLBACK(Stylus_Press), NULL); g_signal_connect(G_OBJECT(pDrawingArea), "button_release_event", G_CALLBACK(Stylus_Release), NULL); g_signal_connect(G_OBJECT(pDrawingArea), "motion_notify_event", G_CALLBACK(Stylus_Move), NULL); g_signal_connect( G_OBJECT(pDrawingArea), "realize", G_CALLBACK(Draw), NULL ) ; g_signal_connect( G_OBJECT(pDrawingArea), "expose_event", G_CALLBACK(gtkFloatExposeEvent), NULL ) ; gtk_box_pack_start(GTK_BOX(pVBox), pDrawingArea, FALSE, FALSE, 0); /* Création de la barre d'état */ pStatusBar = gtk_statusbar_new(); pStatusBar_Ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(pStatusBar), "Global"); pStatusBar_Change("Desmume"); gtk_box_pack_end(GTK_BOX(pVBox), pStatusBar, FALSE, FALSE, 0); gtk_widget_show_all(pWindow); //LoadFirmware("fw.bin"); /* Vérifie la ligne de commandes */ if(commandLine_File) { if(Open(commandLine_File) >= 0) { Launch(); } else { GtkWidget *pDialog = gtk_message_dialog_new(GTK_WINDOW(pWindow), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Unable to load :\n%s", commandLine_File); gtk_dialog_run(GTK_DIALOG(pDialog)); gtk_widget_destroy(pDialog); } } /* Boucle principale */ // gtk_idle_add(&EmuLoop, pWindow); // g_idle_add(&EmuLoop, pWindow); gtk_main(); desmume_free(); #ifdef DEBUG LogStop(); #endif SDL_Quit(); Write_ConfigFile(); return EXIT_SUCCESS; }