bool wxApp::OnInitGui() { if ( !wxAppBase::OnInitGui() ) return false; #ifndef __WXGTK3__ // if this is a wxGLApp (derived from wxApp), and we've already // chosen a specific visual, then derive the GdkVisual from that if ( GetXVisualInfo() ) { GdkVisual* vis = gtk_widget_get_default_visual(); GdkColormap *colormap = gdk_colormap_new( vis, FALSE ); gtk_widget_set_default_colormap( colormap ); } else { // On some machines, the default visual is just 256 colours, so // we make sure we get the best. This can sometimes be wasteful. if (m_useBestVisual) { if (m_forceTrueColour) { GdkVisual* visual = gdk_visual_get_best_with_both( 24, GDK_VISUAL_TRUE_COLOR ); if (!visual) { wxLogError(wxT("Unable to initialize TrueColor visual.")); return false; } GdkColormap *colormap = gdk_colormap_new( visual, FALSE ); gtk_widget_set_default_colormap( colormap ); } else { if (gdk_visual_get_best() != gdk_visual_get_system()) { GdkVisual* visual = gdk_visual_get_best(); GdkColormap *colormap = gdk_colormap_new( visual, FALSE ); gtk_widget_set_default_colormap( colormap ); } } } } #endif #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 if ( !GetHildonProgram() ) { wxLogError(_("Unable to initialize Hildon program")); return false; } #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2 return true; }
int main(int argc, char* argv[]) { gtk_init(&argc, &argv); if (argc == 1) { printf("Usage: URI\n"); return 1; } const char *uri = argv[1]; if(!g_thread_supported()) g_thread_init(NULL); // Create a Window, set colormap to RGBA GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); GdkScreen *screen = gtk_widget_get_screen(window); #if GTK_CHECK_VERSION(3, 0, 0) GdkVisual *visual = gdk_screen_get_rgba_visual(screen); if (visual && gdk_screen_is_composited (screen)) { gtk_widget_set_visual(GTK_WIDGET(window), visual); } #else GdkColormap *rgba = gdk_screen_get_rgba_colormap (screen);s if (rgba && gdk_screen_is_composited (screen)) { gtk_widget_set_default_colormap(rgba); gtk_widget_set_default_colormap(rgba); } #endif gtk_window_set_default_size(GTK_WINDOW(window), 600, 400); g_signal_connect(window, "destroy", G_CALLBACK(destroy_cb), NULL); // Optional: for dashboard style borderless windows gtk_window_set_decorated(GTK_WINDOW(window), FALSE); // Create a WebView, set it transparent, add it to the window WebKitWebView* web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); webkit_web_view_set_transparent(web_view, TRUE); gtk_container_add (GTK_CONTAINER(window), GTK_WIDGET(web_view)); // Load a default page webkit_web_view_load_uri(web_view, uri); // Show it and continue running until the window closes gtk_widget_grab_focus(GTK_WIDGET(web_view)); gtk_widget_show_all(window); gtk_main(); return 0; }
/** * gimp_ui_init: * @prog_name: The name of the plug-in which will be passed as argv[0] to * gtk_init(). It's a convention to use the name of the * executable and _not_ the PDB procedure name. * @preview: This parameter is unused and exists for historical * reasons only. * * This function initializes GTK+ with gtk_init() and initializes GDK's * image rendering subsystem (GdkRGB) to follow the GIMP main program's * colormap allocation/installation policy. * * It also sets up various other things so that the plug-in user looks * and behaves like the GIMP core. This includes selecting the GTK+ * theme and setting up the help system as chosen in the GIMP * preferences. Any plug-in that provides a user interface should call * this function. **/ void gimp_ui_init (const gchar *prog_name, gboolean preview) { GdkScreen *screen; const gchar *display_name; gchar *themerc; g_return_if_fail (prog_name != NULL); if (gimp_ui_initialized) return; g_set_prgname (prog_name); display_name = gimp_display_name (); if (display_name) { #if defined (GDK_WINDOWING_X11) g_setenv ("DISPLAY", display_name, TRUE); #else g_setenv ("GDK_DISPLAY", display_name, TRUE); #endif } if (gimp_user_time ()) { /* Construct a fake startup ID as we only want to pass the * interaction timestamp, see _gdk_windowing_set_default_display(). */ gchar *startup_id = g_strdup_printf ("_TIME%u", gimp_user_time ()); g_setenv ("DESKTOP_STARTUP_ID", startup_id, TRUE); g_free (startup_id); } gtk_init (NULL, NULL); themerc = gimp_personal_rc_file ("themerc"); gtk_rc_add_default_file (themerc); g_free (themerc); gdk_set_program_class (gimp_wm_class ()); screen = gdk_screen_get_default (); gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (screen)); gimp_widgets_init (gimp_ui_help_func, gimp_context_get_foreground, gimp_context_get_background, gimp_ensure_modules); if (! gimp_show_tool_tips ()) gimp_help_disable_tooltips (); gimp_dialogs_show_help_button (gimp_show_help_button ()); gimp_ui_initialized = TRUE; }
void init_ui(void) { int argc; char **argv; GtkWidget* dlg; disp = malloc(WWIDTH*WHEIGHT*3); argc = 1; argv = g_new (gchar *, 1); argv[0] = g_strdup ("myprog"); gtk_init (&argc, &argv); gdk_rgb_init (); gtk_widget_set_default_visual (gdk_rgb_get_visual()); gtk_widget_set_default_colormap (gdk_rgb_get_cmap()); dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER); gtk_signal_connect (GTK_OBJECT (dlg), "destroy", (GtkSignalFunc) gtk_main_quit, NULL); gtk_window_set_title (GTK_WINDOW (dlg), "FLYNN"); eventbox = gtk_event_box_new(); gtk_container_border_width (GTK_CONTAINER (eventbox), 0); gtk_container_add (GTK_CONTAINER (dlg), GTK_WIDGET (eventbox)); drawing_area = gtk_drawing_area_new (); gtk_widget_set_usize (drawing_area, WWIDTH, WHEIGHT); gtk_container_add (GTK_CONTAINER (eventbox), GTK_WIDGET (drawing_area)); gtk_widget_show (drawing_area); gtk_widget_show (eventbox); gtk_widget_add_events (dlg, GDK_KEY_PRESS_MASK); gtk_signal_connect (GTK_OBJECT (dlg), "key_press_event", (GtkSignalFunc) key_press, NULL); gtk_widget_show (dlg); /* gdk_key_repeat_disable (); */ /* gdk_keyboard_grab (eventbox->window, FALSE, time); */ }
/** * gimp_ui_init: * @prog_name: The name of the plug-in which will be passed as argv[0] to * gtk_init(). It's a convention to use the name of the * executable and _not_ the PDB procedure name or something. * @preview: This parameter is unused and exists for historical * reasons only. * * This function initializes GTK+ with gtk_init() and initializes GDK's * image rendering subsystem (GdkRGB) to follow the GIMP main program's * colormap allocation/installation policy. * * GIMP's colormap policy can be determinded by the user with the * gimprc variables @min_colors and @install_cmap. **/ void gimp_ui_init (const gchar *prog_name, gboolean preview) { const gchar *display_name; gchar *themerc; GdkScreen *screen; g_return_if_fail (prog_name != NULL); if (gimp_ui_initialized) return; g_set_prgname (prog_name); display_name = gimp_display_name (); if (display_name) { #if defined (GDK_WINDOWING_X11) const gchar var_name[] = "DISPLAY"; #else const gchar var_name[] = "GDK_DISPLAY"; #endif putenv (g_strdup_printf ("%s=%s", var_name, display_name)); } gtk_init (NULL, NULL); themerc = gimp_personal_rc_file ("themerc"); gtk_rc_add_default_file (themerc); g_free (themerc); gdk_set_program_class (gimp_wm_class ()); gdk_rgb_set_min_colors (gimp_min_colors ()); gdk_rgb_set_install (gimp_install_cmap ()); screen = gdk_screen_get_default (); gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (screen)); gimp_widgets_init (gimp_ui_help_func, gimp_context_get_foreground, gimp_context_get_background, gimp_ensure_modules); if (! gimp_show_tool_tips ()) gimp_help_disable_tooltips (); gimp_dialogs_show_help_button (gimp_show_help_button ()); gimp_ui_initialized = TRUE; }
int dodisplay(int argc, char *argv[]) { GIOChannel *chan; struct imgrect *ir; /* have our main loop poll the pipe file descriptor */ chan = g_io_channel_unix_new(dpychld_fd); g_io_add_watch(chan, G_IO_IN | G_IO_ERR | G_IO_HUP, (GIOFunc)pipe_event, NULL); fcntl(dpychld_fd, F_SETFL, O_NONBLOCK); /* set up list of image rectangles. */ imgrects = calloc(nimgrects = 16, sizeof *imgrects); /* do some init thing */ gtk_init(&argc, &argv); gdk_rgb_init(); gtk_widget_set_default_colormap(gdk_rgb_get_cmap()); gtk_widget_set_default_visual(gdk_rgb_get_visual()); /* Make our own window. */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_usize(window, 0, 0); darea = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER(window), darea); gtk_widget_set_events(darea, GDK_EXPOSURE_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK); gtk_signal_connect(GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(delete_event), NULL); gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(destroy), NULL); gtk_signal_connect(GTK_OBJECT(darea), "expose-event", GTK_SIGNAL_FUNC(expose_event), NULL); gtk_signal_connect(GTK_OBJECT(darea), "configure_event", GTK_SIGNAL_FUNC(expose_event), NULL); /* mouse button press/release for saving images */ gtk_signal_connect(GTK_OBJECT(darea), "button_press_event", GTK_SIGNAL_FUNC(button_press_event), NULL); gtk_signal_connect(GTK_OBJECT(darea), "button_press_event", GTK_SIGNAL_FUNC(button_release_event), NULL); gtk_widget_show_all(window); gtk_main(); /* Get rid of all remaining images. */ for (ir = imgrects; ir < imgrects + nimgrects; ++ir) if (ir->filename) unlink(ir->filename); return 0; }
int main (int argc, char **argv) { GdkWindow *root; GtkWidget *window; GtkWidget *vbox; GtkWidget *drawing_area; GdkPixbuf *pixbuf; pixbuf_init (); gtk_init (&argc, &argv); gdk_rgb_set_verbose (TRUE); gtk_widget_set_default_colormap (gdk_rgb_get_colormap ()); root = gdk_get_default_root_window (); pixbuf = gdk_pixbuf_get_from_drawable (NULL, root, NULL, 0, 0, 0, 0, 150, 160); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "delete_event", G_CALLBACK (close_app), NULL); g_signal_connect (window, "destroy", G_CALLBACK (close_app), NULL); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (GTK_WIDGET (drawing_area), gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf)); g_signal_connect (drawing_area, "expose_event", G_CALLBACK (expose_cb), NULL); g_signal_connect (drawing_area, "configure_event", G_CALLBACK (configure_cb), NULL); g_object_set_data (G_OBJECT (drawing_area), "pixbuf", pixbuf); gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0); gtk_widget_show_all (window); gtk_main (); return 0; }
/** * Basic (i.e. minimal) initialization of libdia. * * It does not load any plug-ins but instead brings libdia to a state that plug-in loading can take place. * @param flags a set of DIA_INTERACTIVE, DIA_MESSAGE_STDERR */ void libdia_init (guint flags) { static gboolean initialized = FALSE; if (initialized) return; if (flags & DIA_MESSAGE_STDERR) set_message_func(stderr_message_internal); LIBXML_TEST_VERSION; #ifdef G_OS_WIN32 xmlSetGenericErrorFunc(NULL, myXmlErrorReporting); #endif if (flags & DIA_VERBOSE) { dia_log_message_enable (TRUE); dia_log_message ("initializing libdia"); } stdprops_init(); if (flags & DIA_INTERACTIVE) { char *diagtkrc; gtk_widget_set_default_colormap(gdk_rgb_get_cmap()); diagtkrc = dia_config_filename("diagtkrc"); dia_log_message ("Config from %s", diagtkrc); gtk_rc_parse(diagtkrc); g_free(diagtkrc); color_init(); } initialized = TRUE; object_registry_init(); /* The group_type is registered in app, but it needs to be exported anyway */ object_register_type(&stdpath_type); }
int main(int argc, char* argv[]) { IBusComponent *component; IBusEngineDesc * desc; GError * err = NULL; gboolean have_ibus=FALSE; const gchar * language="zh"; const gchar * icon_dir = NULL; const gchar * locale_dir = NULL; setlocale(LC_ALL, ""); gtk_set_locale(); textdomain(GETTEXT_PACKAGE); GOptionEntry args[] = { {"ibus",'\0',0,G_OPTION_ARG_NONE,&have_ibus}, {"icondir",'\0',0,G_OPTION_ARG_STRING,&icon_dir,_("the icon file"),N_("icon file")}, {"table",'\0',0,G_OPTION_ARG_STRING,&tablefile,_("set table file path"),N_("tablefile")}, {"locale",'\0',0,G_OPTION_ARG_STRING,&locale_dir,_("set locale path"),N_("locale")}, #ifdef WITH_ZINNIA {"lang",'\0',0,G_OPTION_ARG_STRING,&language,_("set languate, accept zh and jp"),N_("lang")}, #endif {0} }; gtk_init_with_args(&argc,&argv,PACKAGE_NAME,args,PACKAGE_NAME,&err); if(G_UNLIKELY(!gtk_gl_init_check(&argc, &argv))) { g_warning("GLX extension not available, use slow soft cairo rendering instead"); } #ifdef WITH_ZINNIA if(strcmp(language,"zh")==0 ||strcmp(language,"zh_CN") ==0 ) { }else if( strcmp(language,"jp") ==0 || strcmp(language,"ja")==0 ) { g_strlcpy(lang,"ja",20); }else { g_error("pass jp or zh to --lang!"); } #endif if(locale_dir) { bindtextdomain(GETTEXT_PACKAGE,locale_dir); } gchar * engine_name = g_strdup_printf("handwrite-%s",lang); gchar * dbus_name = g_strdup_printf("org.freedesktop.IBus.handwrite-%s",lang); ibus_init(); if(icon_dir) realpath(icon_dir, icondir); bus = ibus_bus_new(); g_signal_connect (bus, "disconnected", G_CALLBACK (gtk_main_quit), NULL); factory = ibus_factory_new(ibus_bus_get_connection(bus)); ibus_bus_request_name(bus, dbus_name, 0); // g_free(dbus_name); if (!have_ibus) { char * exefile ; exefile = realpath(argv[0],NULL); component = ibus_component_new(dbus_name, "handwrite", PACKAGE_VERSION, "GPL", MICROCAI_WITHEMAIL, PACKAGE_BUGREPORT, exefile, GETTEXT_PACKAGE); gchar * iconfile = g_strdup_printf("%s/ibus-handwrite.svg",icondir); desc = ibus_engine_desc_new(engine_name, "handwrite", _("hand write recognizer"), lang, "GPL", MICROCAI_WITHEMAIL, iconfile, "us"); ibus_component_add_engine(component, desc); free(exefile); g_free(iconfile); }else { component = ibus_component_new(dbus_name, "handwrite", PACKAGE_VERSION, "GPL", MICROCAI_WITHEMAIL, PACKAGE_BUGREPORT, PKGDATADIR, GETTEXT_PACKAGE); } g_free(dbus_name); ibus_bus_register_component(bus, component); ibus_factory_add_engine(factory, engine_name, IBUS_TYPE_HANDWRITE_ENGINE); g_free(engine_name); g_object_unref(component); GdkScreen * screen = gdk_screen_get_default(); GdkColormap * map = gdk_screen_get_rgba_colormap(screen); if(map) gtk_widget_set_default_colormap(map); printf(_("ibus-handwrite Version %s Start Up\n"), PACKAGE_VERSION); gtk_main(); return 0; }
int main (int argc, char **argv) { int i; int found_valid = FALSE; GdkPixbuf *pixbuf; GdkPixbufLoader *pixbuf_loader; gtk_init (&argc, &argv); gdk_rgb_set_verbose (TRUE); gdk_rgb_init (); gtk_widget_set_default_colormap (gdk_rgb_get_cmap ()); gtk_widget_set_default_visual (gdk_rgb_get_visual ()); { char *tbf_readlen = getenv("TBF_READLEN"); if(tbf_readlen) readlen = atoi(tbf_readlen); } { char *tbf_bps = getenv("TBF_KBPS"); guint bps; if (tbf_bps) { bps = atoi(tbf_bps); g_print ("Simulating %d kBytes/sec\n", bps); readlen = (bps*1024)/10; } } i = 1; if (argc == 1) { const gchar*** xpmp; pixbuf = gdk_pixbuf_new_from_data (default_image, GDK_COLORSPACE_RGB, FALSE, 8, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_WIDTH * 3, NULL, NULL); new_testrgb_window (pixbuf, NULL); xpmp = xpms; while (*xpmp) { pixbuf = gdk_pixbuf_new_from_xpm_data (*xpmp); new_testrgb_window (pixbuf, NULL); ++xpmp; } found_valid = TRUE; } else { for (i = 1; i < argc; i++) { pixbuf = gdk_pixbuf_new_from_file (argv[i]); #if 0 pixbuf = gdk_pixbuf_rotate(pixbuf, 10.0); #endif if (pixbuf) { new_testrgb_window (pixbuf, "File"); found_valid = TRUE; } } #if 1 { GtkWidget* rgb_window = NULL; ProgressFileStatus status; pixbuf_loader = gdk_pixbuf_loader_new (); status.loader = pixbuf_loader; status.rgbwin = &rgb_window; status.buf = g_malloc (readlen); gtk_signal_connect(GTK_OBJECT(pixbuf_loader), "area_prepared", GTK_SIGNAL_FUNC(progressive_prepared_callback), &rgb_window); gtk_signal_connect(GTK_OBJECT(pixbuf_loader), "area_updated", GTK_SIGNAL_FUNC(progressive_updated_callback), &rgb_window); status.imagefile = fopen (argv[1], "r"); g_assert (status.imagefile != NULL); status.readlen = readlen; status.timeout = gtk_timeout_add(100, update_timeout, &status); } #endif } if (found_valid) gtk_main (); return 0; }
static VALUE rg_s_set_default_colormap(G_GNUC_UNUSED VALUE self, VALUE cmap) { gtk_widget_set_default_colormap(GDK_COLORMAP(RVAL2GOBJ(cmap))); return cmap; }
GimpInitStatusFunc gui_init (Gimp *gimp, gboolean no_splash) { GimpInitStatusFunc status_callback = NULL; gchar *abort_message; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (the_gui_gimp == NULL, NULL); abort_message = gui_sanity_check (); if (abort_message) gui_abort (abort_message); the_gui_gimp = gimp; /* TRANSLATORS: there is no need to translate this in GIMP. This uses * "gtk20" domain as a special trick to determine language direction, * but xgettext extracts it anyway mistakenly into GIMP po files. * Leave an empty string as translation. It does not matter. */ if (g_strcmp0 (dgettext ("gtk20", "default:LTR"), "default:RTL") == 0) /* Normally this should have been taken care of during command line * parsing as a post-parse hook of gtk_get_option_group(), using the * system locales. * But user config may have overriden the language, therefore we must * check the widget directions again. */ gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); else gtk_widget_set_default_direction (GTK_TEXT_DIR_LTR); gui_unique_init (gimp); gimp_language_store_parser_init (); gimp_widgets_init (gui_help_func, gui_get_foreground_func, gui_get_background_func, NULL); g_type_class_ref (GIMP_TYPE_COLOR_SELECT); /* disable automatic startup notification */ gtk_window_set_auto_startup_notification (FALSE); gimp_dnd_init (gimp); themes_init (gimp); initial_monitor = gimp_get_monitor_at_pointer (&initial_screen); gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (initial_screen)); if (! no_splash) { splash_create (gimp->be_verbose, initial_screen, initial_monitor); status_callback = splash_update; } g_signal_connect_after (gimp, "initialize", G_CALLBACK (gui_initialize_after_callback), NULL); g_signal_connect (gimp, "restore", G_CALLBACK (gui_restore_callback), NULL); g_signal_connect_after (gimp, "restore", G_CALLBACK (gui_restore_after_callback), NULL); g_signal_connect (gimp, "exit", G_CALLBACK (gui_exit_callback), NULL); g_signal_connect_after (gimp, "exit", G_CALLBACK (gui_exit_after_callback), NULL); return status_callback; }
int main (int argc, char *argv[]) { DVDResult_t res; char *msgq_str; program_name = argv[0]; #ifdef ENABLE_NLS setlocale(LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); #endif if(argc==1) { fprintf(stderr, "Error: Do not start ogle_gui directly. Start ogle\n"); exit(1); } if(pipe(dvdpipe)) { FATAL("dvdpipe: %s", strerror(errno)); exit(1); } msgq_str = argv[2]; init_interpret_config(program_name, add_keybinding, set_dvd_path); interpret_config(); gtk_init(&argc, &argv); dvdpipe_handler_id = gtk_input_add_full(dvdpipe[0], GDK_INPUT_READ, dvdpipe_handler, NULL, NULL, NULL); // Make Solaris 8+24 displays work gdk_rgb_init(); gtk_widget_set_default_colormap(gdk_rgb_get_cmap()); gtk_widget_set_default_visual(gdk_rgb_get_visual()); // Initialize glade, and read in the glade file my_glade_setup(); res = DVDOpenNav(&nav, msgq_str); if(res != DVD_E_Ok ) { DVDPerror("DVDOpen", res); exit(1); } xsniff_init(msgq_str); audio_menu_new(); subpicture_menu_new(); app = get_glade_widget("app"); gtk_widget_show(app); menu_new(app); // If a filename is given on the command line, start immediately. if(argc == 4) { res = DVDSetDVDRoot(nav, argv[3]); if(res != DVD_E_Ok) { DVDPerror("main: DVDSetDVDRoot", res); } autoload_bookmark(); } gtk_main (); return 0; }
int main (int argc, char **argv) { int i; int found_valid = FALSE; GdkPixbufAnimation *animation; gtk_init (&argc, &argv); gdk_rgb_set_verbose (TRUE); gdk_rgb_init (); gtk_widget_set_default_colormap (gdk_rgb_get_cmap ()); gtk_widget_set_default_visual (gdk_rgb_get_visual ()); { char *tbf_readlen = getenv("TBF_READLEN"); if(tbf_readlen) readlen = atoi(tbf_readlen); } { char *tbf_bps = getenv("TBF_KBPS"); guint bps; if (tbf_bps) { bps = atoi(tbf_bps); g_print ("Simulating %d kBytes/sec\n", bps); readlen = (bps*1024)/10; } } i = 1; if (argc == 1) { g_print ("USAGE: testanimation FILE1 ...\n"); return 0; } else { for (i = 1; i < argc; i++) { animation = gdk_pixbuf_animation_new_from_file (argv[i]); if (animation) { gint i = 0; GList *listptr; for (listptr = gdk_pixbuf_animation_get_frames (animation); listptr; listptr = listptr->next) { GdkPixbufFrame *frame; GdkPixbuf *pixbuf; gchar *title; frame = listptr->data; pixbuf = gdk_pixbuf_frame_get_pixbuf (frame); title = g_strdup_printf ("Frame %d", i); g_print ("Frame %d x:%d y:%d width:%d height:%d\n", i, gdk_pixbuf_frame_get_x_offset (frame), gdk_pixbuf_frame_get_y_offset (frame), gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf)); new_testrgb_window (pixbuf, title); g_free (title); i++; } found_valid = TRUE; } } #if 0 { GtkWidget* rgb_window = NULL; ProgressFileStatus status; GdkPixbufLoader *pixbuf_loader; pixbuf_loader = gdk_pixbuf_loader_new (); status.loader = pixbuf_loader; status.rgbwin = &rgb_window; status.buf = g_malloc (readlen); gtk_signal_connect(GTK_OBJECT(pixbuf_loader), "area_prepared", GTK_SIGNAL_FUNC(progressive_prepared_callback), &rgb_window); gtk_signal_connect(GTK_OBJECT(pixbuf_loader), "area_updated", GTK_SIGNAL_FUNC(progressive_updated_callback), &rgb_window); status.imagefile = fopen (argv[1], "r"); g_assert (status.imagefile != NULL); status.readlen = readlen; status.timeout = gtk_timeout_add(100, update_timeout, &status); } #endif } if (found_valid) gtk_main (); return 0; }
int main (int argc, char **argv) { int i; int found_valid = FALSE; GdkPixbuf *pixbuf; GdkPixbufLoader *pixbuf_loader; pixbuf_init (); gtk_init (&argc, &argv); /* gdk_rgb_set_verbose (TRUE);*/ gtk_widget_set_default_colormap (gdk_rgb_get_colormap ()); { char *tbf_readlen = getenv ("TBF_READLEN"); if (tbf_readlen) readlen = atoi (tbf_readlen); } { char *tbf_bps = getenv ("TBF_KBPS"); guint bps; if (tbf_bps) { bps = atoi (tbf_bps); g_print ("Simulating %d kBytes/sec\n", bps); readlen = (bps*1024)/10; } } i = 1; if (argc == 1) { const gchar*** xpmp; GError *error = NULL; pixbuf = gdk_pixbuf_new_from_data (default_image, GDK_COLORSPACE_RGB, FALSE, 8, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_WIDTH * 3, NULL, NULL); new_testrgb_window (pixbuf, NULL); xpmp = xpms; while (*xpmp) { pixbuf = gdk_pixbuf_new_from_xpm_data (*xpmp); new_testrgb_window (pixbuf, NULL); ++xpmp; } /* Test loading from inline data. */ pixbuf = gdk_pixbuf_new_from_inline (-1, apple_red, FALSE, &error); if (!pixbuf) { fprintf (stderr, "failed to construct \"red apple\" pixbuf: %s\n", error->message); g_error_free (error); } else new_testrgb_window (pixbuf, "Red apple from inlined RLE data"); pixbuf = gdk_pixbuf_new_from_inline (sizeof (gnome_foot), gnome_foot, TRUE, NULL); new_testrgb_window (pixbuf, "GNOME Foot from inlined RLE data"); found_valid = TRUE; } else { for (i = 1; i < argc; i++) { GError *error; error = NULL; pixbuf = gdk_pixbuf_new_from_file (argv[i], &error); if (pixbuf == NULL) { g_warning ("Error loading image: %s", error->message); g_error_free (error); } #if 0 pixbuf = gdk_pixbuf_rotate (pixbuf, 10.0); #endif if (pixbuf) { new_testrgb_window (pixbuf, "File"); found_valid = TRUE; } } #if 1 { GtkWidget* rgb_window = NULL; ProgressFileStatus status; pixbuf_loader = gdk_pixbuf_loader_new (); status.loader = pixbuf_loader; status.rgbwin = &rgb_window; status.buf = g_malloc (readlen); #if 0 g_signal_connect (pixbuf_loader, "size_prepared", G_CALLBACK (size_func), NULL); #endif g_signal_connect (pixbuf_loader, "area_prepared", G_CALLBACK (progressive_prepared_callback), &rgb_window); g_signal_connect (pixbuf_loader, "area_updated", G_CALLBACK (progressive_updated_callback), &rgb_window); status.imagefile = fopen (argv[1], "r"); g_assert (status.imagefile != NULL); status.readlen = readlen; status.timeout = gdk_threads_add_timeout (100, update_timeout, &status); } #endif } if (found_valid) gtk_main (); return 0; }
void create_main_window (ProcData *procdata) { gint width, height; GtkWidget *app; GtkAction *action; GtkWidget *menubar; GtkWidget *main_box; GtkWidget *notebook; GtkWidget *tab_label1, *tab_label2, *tab_label3; GtkWidget *vbox1; GtkWidget *sys_box, *devices_box; GtkWidget *sysinfo_box, *sysinfo_label; app = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(app), _("System Monitor")); GdkScreen* screen = gtk_widget_get_screen(app); GdkColormap* colormap = gdk_screen_get_rgba_colormap(screen); /* use rgba colormap, if available */ if (colormap) gtk_widget_set_default_colormap(colormap); main_box = gtk_vbox_new (FALSE, 0); gtk_container_add(GTK_CONTAINER(app), main_box); width = procdata->config.width; height = procdata->config.height; gtk_window_set_default_size (GTK_WINDOW (app), width, height); gtk_window_set_resizable (GTK_WINDOW (app), TRUE); /* create the menubar */ procdata->uimanager = gtk_ui_manager_new (); /* show tooltips in the statusbar */ g_signal_connect (procdata->uimanager, "connect_proxy", G_CALLBACK (connect_proxy_cb), procdata); g_signal_connect (procdata->uimanager, "disconnect_proxy", G_CALLBACK (disconnect_proxy_cb), procdata); gtk_window_add_accel_group (GTK_WINDOW (app), gtk_ui_manager_get_accel_group (procdata->uimanager)); if (!gtk_ui_manager_add_ui_from_string (procdata->uimanager, ui_info, -1, NULL)) { g_error("building menus failed"); } procdata->action_group = gtk_action_group_new ("ProcmanActions"); gtk_action_group_set_translation_domain (procdata->action_group, NULL); gtk_action_group_add_actions (procdata->action_group, menu_entries, G_N_ELEMENTS (menu_entries), procdata); gtk_action_group_add_toggle_actions (procdata->action_group, toggle_menu_entries, G_N_ELEMENTS (toggle_menu_entries), procdata); gtk_action_group_add_radio_actions (procdata->action_group, radio_menu_entries, G_N_ELEMENTS (radio_menu_entries), procdata->config.whose_process, G_CALLBACK(cb_radio_processes), procdata); gtk_ui_manager_insert_action_group (procdata->uimanager, procdata->action_group, 0); menubar = gtk_ui_manager_get_widget (procdata->uimanager, "/MenuBar"); gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0); /* create the main notebook */ procdata->notebook = notebook = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (main_box), notebook, TRUE, TRUE, 0); sysinfo_box = gtk_hbox_new(TRUE, 0); // procman_create_sysinfo_view(); sysinfo_label = gtk_label_new(_("System")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sysinfo_box, sysinfo_label); vbox1 = create_proc_view (procdata); tab_label1 = gtk_label_new (_("Processes")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox1, tab_label1); sys_box = create_sys_view (procdata); tab_label2 = gtk_label_new (_("Resources")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label2); devices_box = create_disk_view (procdata); tab_label3 = gtk_label_new (_("File Systems")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), devices_box, tab_label3); g_signal_connect (G_OBJECT (notebook), "switch-page", G_CALLBACK (cb_switch_page), procdata); g_signal_connect (G_OBJECT (notebook), "change-current-page", G_CALLBACK (cb_change_current_page), procdata); gtk_widget_show_all(notebook); // need to make page switch work gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab); cb_change_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab, procdata); g_signal_connect (G_OBJECT (app), "delete_event", G_CALLBACK (cb_app_delete), procdata); /* create the statusbar */ procdata->statusbar = gtk_statusbar_new(); gtk_box_pack_end(GTK_BOX(main_box), procdata->statusbar, FALSE, FALSE, 0); procdata->tip_message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (procdata->statusbar), "tip_message"); action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies"); gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), procdata->config.show_tree); gtk_widget_show_all(app); procdata->app = app; }
int main( int argc, char *argv[]) { GtkWidget *window; GtkWidget *button; GtkWidget *vbox; playback_t play = { 0 }; /* Option parsing */ GError *error = NULL; GOptionContext *context; GOptionEntry entries[] = { { "input-filename", 'i', 0, G_OPTION_ARG_FILENAME, &(play.filename), "Input filename", "FILE" }, { NULL } }; context = g_option_context_new("- Firefly MV Camera Playback"); g_option_context_set_summary(context, "Replays successive frames previously recorded\n" "using dc1394-record"); g_option_context_add_main_entries (context, entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { printf( "Error: %s\n%s", error->message, g_option_context_get_help(context, TRUE, NULL)); exit(1); } if (play.filename == NULL) { printf( "Error: You must supply a filename\n%s", g_option_context_get_help(context, TRUE, NULL)); exit(2); } if (play.filename[0] == '-') { play.fp = stdin; } else { play.fp = fopen(play.filename, "rb"); } if( play.fp == NULL ) { perror("opening file"); exit(1); } // read the first frame play.total_frame_size = read_frame(&play.frame, play.fp); if (play.frame.color_coding == DC1394_COLOR_CODING_MONO8) play.show = GRAY; else if (play.frame.color_coding == DC1394_COLOR_CODING_RGB8) play.show = COLOR; else if (play.frame.color_coding == DC1394_COLOR_CODING_RAW8) play.show = FORMAT7; else { perror("invalid color coding"); exit(1); } gtk_init( &argc, &argv ); gdk_rgb_init(); gtk_widget_set_default_colormap (gdk_rgb_get_cmap()); gtk_widget_set_default_visual (gdk_rgb_get_visual()); // create window window = gtk_window_new( GTK_WINDOW_TOPLEVEL ); g_signal_connect( G_OBJECT(window), "delete_event", G_CALLBACK(delete_event), NULL ); g_signal_connect( G_OBJECT(window), "destroy", G_CALLBACK(delete_event), NULL ); gtk_container_set_border_width( GTK_CONTAINER(window), 10 ); // add widgets // vbox (VBox) vbox = gtk_vbox_new(FALSE, 10); gtk_container_add( GTK_CONTAINER(window), vbox ); // canvas (DrawingArea) play.canvas = gtk_drawing_area_new(); gtk_widget_set_size_request(play.canvas, play.frame.size[0], play.frame.size[1]); g_signal_connect (G_OBJECT (play.canvas), "expose_event", G_CALLBACK (expose_event_callback), &play); gtk_widget_set_events(play.canvas, GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK ); g_signal_connect( G_OBJECT(play.canvas), "button_press_event", G_CALLBACK(canvas_button_press), &play); gtk_box_pack_start(GTK_BOX(vbox), play.canvas, TRUE, TRUE, 0); // quit button button = gtk_button_new_with_label( "Quit" ); g_signal_connect_swapped( G_OBJECT(button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(window) ); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, TRUE, 0); // play button button = gtk_button_new_with_label( "Play" ); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (on_play_clicked_event), (gpointer) &play); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, TRUE, 0); // display everything gtk_widget_show_all( window ); // render the first frame renderframe(0, &play); // go gtk_main(); fclose(play.fp); return 0; }
int main (int argc, char ** argv) { GtkMngView * mng_view; GtkWidget * window; GtkWidget * align; GtkWidget * frame; guchar * mng_data = NULL; guint mng_data_size; if (argc < 2) { g_print ("Usage: %s <file.mng>\n\n", argv[0]); g_print (" Compiled with GTK+ %d.%d.%d; using GTK+ %d.%d.%d.\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION, gtk_major_version, gtk_minor_version, gtk_micro_version); #ifdef GDK_PIXBUF_VERSION g_print (" Compiled with gdk-pixbuf %s; using gdk-pixbuf %s.\n", GDK_PIXBUF_VERSION, gdk_pixbuf_version); #endif g_print (" Compiled with libmng %s; using libmng %s.\n", MNG_VERSION_TEXT, mng_version_text()); g_print (" Compiled with zlib %s; using zlib %s.\n", ZLIB_VERSION, zlib_version); #ifdef JPEG_LIB_VERSION { int major = JPEG_LIB_VERSION / 10; int minor = JPEG_LIB_VERSION % 10; char minoralpha[2]; if (minor) { minoralpha[0] = (char)(minor - 1 + 'a'); minoralpha[1] = '\0'; } else minoralpha[0] = '\0'; g_print (" Compiled with libjpeg %d%s.\n", major, minoralpha); } #endif g_print ("\nPress Esc or Q, or click mouse button, to quit.\n"); return 1; } mng_data_size = read_file (* (argv + 1), &mng_data); if (mng_data == NULL) return 1; gtk_init (&argc, &argv); gdk_rgb_init (); gdk_rgb_set_verbose (TRUE); gtk_widget_set_default_visual (gdk_rgb_get_visual ()); gtk_widget_set_default_colormap (gdk_rgb_get_cmap ()); window = gtk_widget_new (GTK_TYPE_WINDOW, "GtkWindow::type", GTK_WINDOW_TOPLEVEL, "GtkWindow::title", "MNG animation", "GtkContainer::border_width", 5, NULL); gtk_signal_connect (GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); /* any keypress (e.g., Esc or Q) or mouse-button click will quit viewer */ gtk_signal_connect (GTK_OBJECT (window), "key_press_event", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK); gtk_signal_connect (GTK_OBJECT (window), "button_press_event", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_container_add (GTK_CONTAINER (window), align); frame = gtk_frame_new (NULL); gtk_container_add (GTK_CONTAINER (align), frame); /* actually it */ mng_view = GTK_MNG_VIEW (gtk_mng_view_new ()); gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET (mng_view)); gtk_mng_view_load_mng_from_memory (mng_view, mng_data, mng_data_size); g_free (mng_data); /* rest in piece */ gtk_widget_show_all (window); gtk_main (); return 0; }
void wininit(int *argc, char **argv) { gtk_init(argc, &argv); gtk_widget_set_default_colormap(gdk_rgb_get_cmap()); gtk_widget_set_default_visual(gdk_rgb_get_visual()); }
void gnc_gnome_init (int argc, char **argv, const char * version) { GError *error = NULL; gchar *prefix = gnc_path_get_prefix (); gchar *pkgsysconfdir = gnc_path_get_pkgsysconfdir (); gchar *pkgdatadir = gnc_path_get_pkgdatadir (); gchar *pkglibdir = gnc_path_get_pkglibdir (); gnc_gtk_add_rc_file(); gnucash_program = gnome_program_init( "gnucash", version, LIBGNOMEUI_MODULE, argc, argv, GNOME_PARAM_APP_PREFIX, prefix, GNOME_PARAM_APP_SYSCONFDIR, pkgsysconfdir, GNOME_PARAM_APP_DATADIR, pkgdatadir, GNOME_PARAM_APP_LIBDIR, pkglibdir, GNOME_PARAM_NONE); g_free (prefix); g_free (pkgsysconfdir); g_free (pkgdatadir); g_free (pkglibdir); #ifdef G_OS_WIN32 /* workaround for bug #421792 */ xmlCleanupInputCallbacks(); #endif /* initialization required for gtkhtml */ gtk_widget_set_default_colormap (gdk_rgb_get_colormap ()); /* use custom icon */ { int idx; char *icon_filenames[] = {"gnucash-icon-16x16.png", "gnucash-icon-32x32.png", "gnucash-icon-48x48.png", NULL }; GList *icons = NULL; char *fullname, *name_iter; for (idx = 0; icon_filenames[idx] != NULL; idx++) { GdkPixbuf *buf = NULL; fullname = gnc_gnome_locate_pixmap(icon_filenames[idx]); if (fullname == NULL) { g_warning("couldn't find icon file [%s]", icon_filenames[idx]); continue; } buf = gnc_gnome_get_gdkpixbuf(fullname); if (buf == NULL) { g_warning("error loading image from [%s]", fullname); g_free(fullname); continue; } g_free(fullname); icons = g_list_append(icons, buf); } gtk_window_set_default_icon_list(icons); g_list_foreach(icons, (GFunc)g_object_unref, NULL); g_list_free(icons); } druid_gconf_install_check_schemas(); return; }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkToolkit_gtkInit (JNIEnv *env, jclass clazz __attribute__((unused)), jint portableNativeSync) { int argc = 1; char **argv; char *homedir, *rcpath = NULL; gtkgenericpeer = (*env)->FindClass(env, "gnu/java/awt/peer/gtk/GtkGenericPeer"); gtkgenericpeer = (*env)->NewGlobalRef(env, gtkgenericpeer); printCurrentThreadID = (*env)->GetStaticMethodID (env, gtkgenericpeer, "printCurrentThread", "()V"); NSA_INIT (env, gtkgenericpeer); g_assert((*env)->GetJavaVM(env, &java_vm) == 0); /* GTK requires a program's argc and argv variables, and requires that they be valid. Set it up. */ argv = (char **) g_malloc (sizeof (char *) * 2); argv[0] = (char *) g_malloc(1); argv[0][0] = '\0'; argv[1] = NULL; init_glib_threads(env, portableNativeSync); /* From GDK 2.0 onwards we have to explicitly call gdk_threads_init */ gdk_threads_init(); gtk_init (&argc, &argv); #if SYNCHRONIZE_GDK XSynchronize (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), True); #endif gtk_widget_set_default_colormap (gdk_rgb_get_colormap ()); /* Make sure queued calls don't get sent to GTK/GDK while we're shutting down. */ atexit (gdk_threads_enter); if ((homedir = getenv ("HOME"))) { rcpath = (char *) g_malloc (strlen (homedir) + strlen (RC_FILE) + 2); sprintf (rcpath, "%s/%s", homedir, RC_FILE); } gtk_rc_parse ((rcpath) ? rcpath : RC_FILE); g_free (rcpath); g_free (argv[0]); g_free (argv); /* On errors or warning print a whole stacktrace. */ #if GTK_MINOR_VERSION > 4 old_glog_func = g_log_set_default_handler (&glog_func, NULL); #endif cp_gtk_button_init_jni (); cp_gtk_checkbox_init_jni (); cp_gtk_choice_init_jni (); cp_gtk_component_init_jni (); cp_gtk_filedialog_init_jni (); cp_gtk_list_init_jni (); cp_gtk_menuitem_init_jni (); cp_gtk_scrollbar_init_jni (); cp_gtk_textcomponent_init_jni (); cp_gtk_window_init_jni (); cp_gtk_global_window_group = gtk_window_group_new (); init_dpi_conversion_factor (); }
void gnc_gnome_init (int argc, char **argv, const char * version) { GError *error = NULL; gchar *prefix = gnc_path_get_prefix (); gchar *pkgsysconfdir = gnc_path_get_pkgsysconfdir (); gchar *pkgdatadir = gnc_path_get_pkgdatadir (); gchar *pkglibdir = gnc_path_get_pkglibdir (); gboolean installation_ok = TRUE; /* Verify all the various directory before proceeding */ if (!g_file_test(pkgdatadir, G_FILE_TEST_IS_DIR)) { g_critical("The installation data directory \"%s\" was not found. Your installation is incomplete and cannot be run.", pkgdatadir); installation_ok = FALSE; } if (!g_file_test(pkglibdir, G_FILE_TEST_IS_DIR)) { g_critical("The installation lib directory \"%s\" was not found. Your installation is incomplete and cannot be run.", pkglibdir); installation_ok = FALSE; } if (!g_file_test(pkgsysconfdir, G_FILE_TEST_IS_DIR)) { g_critical("The installation sysconf directory \"%s\" was not found. Your installation is incomplete and cannot be run.", pkgsysconfdir); installation_ok = FALSE; } gnc_gtk_add_rc_file(); gnucash_program = gnome_program_init( "gnucash", version, LIBGNOMEUI_MODULE, argc, argv, GNOME_PARAM_APP_PREFIX, prefix, GNOME_PARAM_APP_SYSCONFDIR, pkgsysconfdir, GNOME_PARAM_APP_DATADIR, pkgdatadir, GNOME_PARAM_APP_LIBDIR, pkglibdir, GNOME_PARAM_NONE); if (!installation_ok) { /* The following string does not need translation because if * it shows up, the program is unusable anyway. */ gnc_error_dialog(NULL, "The installation directories were not found.\n\ndatadir=%s\nlibdir=%s\nsysconfdir=%s\n\nYour installation is incomplete and cannot be run.", pkgdatadir, pkglibdir, pkgsysconfdir); /* gnc_error_dialog must not be called before gnome_program_init. */ } g_free (prefix); g_free (pkgsysconfdir); g_free (pkgdatadir); g_free (pkglibdir); /* Did the installation directory check fail? Terminate * immediately because it will inevitably fail in the glade file * lookup. */ if (!installation_ok) { /* No correct installation? Shut down immediately. */ exit(-1); } #ifdef G_OS_WIN32 /* workaround for bug #421792 */ xmlCleanupInputCallbacks(); #endif /* initialization required for gtkhtml (is it also needed for webkit?) */ gtk_widget_set_default_colormap (gdk_rgb_get_colormap ()); /* use custom icon */ { int idx; char *icon_filenames[] = {"gnucash-icon-16x16.png", "gnucash-icon-32x32.png", "gnucash-icon-48x48.png", NULL }; GList *icons = NULL; char *fullname, *name_iter; for (idx = 0; icon_filenames[idx] != NULL; idx++) { GdkPixbuf *buf = NULL; fullname = gnc_gnome_locate_pixmap(icon_filenames[idx]); if (fullname == NULL) { g_warning("couldn't find icon file [%s]", icon_filenames[idx]); continue; } buf = gnc_gnome_get_gdkpixbuf(fullname); if (buf == NULL) { g_warning("error loading image from [%s]", fullname); g_free(fullname); continue; } g_free(fullname); icons = g_list_append(icons, buf); } gtk_window_set_default_icon_list(icons); g_list_foreach(icons, (GFunc)g_object_unref, NULL); g_list_free(icons); } assistant_gconf_install_check_schemas(); return; }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkMainThread_gtkInit (JNIEnv *env, jclass clazz) { int argc = 1; char **argv; char *homedir, *rcpath = NULL; /* jclass gtkgenericpeer; */ jclass gtkcomponentpeer, gtkchoicepeer, gtkwindowpeer, gtkscrollbarpeer, gtklistpeer, gtkmenuitempeer, gtktextcomponentpeer, window; NSA_INIT (env, clazz); /* GTK requires a program's argc and argv variables, and requires that they be valid. */ argv = (char **) malloc (sizeof (char *) * 2); argv[0] = ""; argv[1] = NULL; /* until we have JDK 1.2 JNI, assume we have a VM with threads that match what GLIB was compiled for */ #ifdef PORTABLE_NATIVE_SYNC (*env)->GetJavaVM( env, &gdk_vm ); g_thread_init ( &g_thread_jni_functions ); printf("called gthread init\n"); #else g_thread_init ( NULL ); #endif /* From GDK 2.0 onwards we have to explicitly call gdk_threads_init */ gdk_threads_init(); gtk_init (&argc, &argv); gdk_rgb_init (); gtk_widget_set_default_colormap (gdk_rgb_get_cmap ()); gtk_widget_set_default_visual (gdk_rgb_get_visual ()); /* Make sure queued calls don't get sent to GTK/GDK while we're shutting down. */ atexit (gdk_threads_enter); gdk_env = env; gdk_event_handler_set ((GdkEventFunc)awt_event_handler, NULL, NULL); if ((homedir = getenv ("HOME"))) { rcpath = (char *) malloc (strlen (homedir) + strlen (RC_FILE) + 2); sprintf (rcpath, "%s/%s", homedir, RC_FILE); } gtk_rc_parse ((rcpath) ? rcpath : RC_FILE); if (rcpath) free (rcpath); free (argv); /* setup cached IDs for posting GTK events to Java */ /* gtkgenericpeer = (*env)->FindClass (env, */ /* "gnu/java/awt/peer/gtk/GtkGenericPeer"); */ window = (*env)->FindClass (env, "java/awt/Window"); gtkcomponentpeer = (*env)->FindClass (env, "gnu/java/awt/peer/gtk/GtkComponentPeer"); gtkchoicepeer = (*env)->FindClass (env, "gnu/java/awt/peer/gtk/GtkChoicePeer"); gtkwindowpeer = (*env)->FindClass (env, "gnu/java/awt/peer/gtk/GtkWindowPeer"); gtkscrollbarpeer = (*env)->FindClass (env, "gnu/java/awt/peer/gtk/GtkScrollbarPeer"); gtklistpeer = (*env)->FindClass (env, "gnu/java/awt/peer/gtk/GtkListPeer"); gtkmenuitempeer = (*env)->FindClass (env, "gnu/java/awt/peer/gtk/GtkMenuItemPeer"); gtktextcomponentpeer = (*env)->FindClass (env, "gnu/java/awt/peer/gtk/GtkTextComponentPeer"); /* gdkColor = (*env)->FindClass (env, */ /* "gnu/java/awt/peer/gtk/GdkColor"); */ /* gdkColorID = (*env)->GetMethodID (env, gdkColor, "<init>", "(III)V"); */ /* postActionEventID = (*env)->GetMethodID (env, gtkgenericpeer, */ /* "postActionEvent", */ /* "(Ljava/lang/String;I)V"); */ setBoundsCallbackID = (*env)->GetMethodID (env, window, "setBoundsCallback", "(IIII)V"); postMenuActionEventID = (*env)->GetMethodID (env, gtkmenuitempeer, "postMenuActionEvent", "()V"); postMouseEventID = (*env)->GetMethodID (env, gtkcomponentpeer, "postMouseEvent", "(IJIIIIZ)V"); postConfigureEventID = (*env)->GetMethodID (env, gtkwindowpeer, "postConfigureEvent", "(IIII)V"); postWindowEventID = (*env)->GetMethodID (env, gtkwindowpeer, "postWindowEvent", "(ILjava/awt/Window;I)V"); postExposeEventID = (*env)->GetMethodID (env, gtkcomponentpeer, "postExposeEvent", "(IIII)V"); postKeyEventID = (*env)->GetMethodID (env, gtkcomponentpeer, "postKeyEvent", "(IJIICI)V"); postFocusEventID = (*env)->GetMethodID (env, gtkcomponentpeer, "postFocusEvent", "(IZ)V"); postAdjustmentEventID = (*env)->GetMethodID (env, gtkscrollbarpeer, "postAdjustmentEvent", "(II)V"); postItemEventID = (*env)->GetMethodID (env, gtkcomponentpeer, "postItemEvent", "(Ljava/lang/Object;I)V"); choicePostItemEventID = (*env)->GetMethodID (env, gtkchoicepeer, "choicePostItemEvent", "(Ljava/lang/String;I)V"); postListItemEventID = (*env)->GetMethodID (env, gtklistpeer, "postItemEvent", "(II)V"); postTextEventID = (*env)->GetMethodID (env, gtktextcomponentpeer, "postTextEvent", "()V"); global_gtk_window_group = gtk_window_group_new (); }
GimpInitStatusFunc gui_init (Gimp *gimp, gboolean no_splash) { GimpInitStatusFunc status_callback = NULL; GdkScreen *screen; gchar *abort_message; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (the_gui_gimp == NULL, NULL); abort_message = gui_sanity_check (); if (abort_message) gui_abort (abort_message); the_gui_gimp = gimp; gui_unique_init (gimp); gimp_widgets_init (gui_help_func, gui_get_foreground_func, gui_get_background_func, NULL); g_type_class_ref (GIMP_TYPE_COLOR_SELECT); /* disable automatic startup notification */ gtk_window_set_auto_startup_notification (FALSE); gimp_dnd_init (gimp); themes_init (gimp); screen = gdk_screen_get_default (); gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (screen)); if (! no_splash) { splash_create (gimp->be_verbose); status_callback = splash_update; } g_signal_connect_after (gimp, "initialize", G_CALLBACK (gui_initialize_after_callback), NULL); g_signal_connect (gimp, "restore", G_CALLBACK (gui_restore_callback), NULL); g_signal_connect_after (gimp, "restore", G_CALLBACK (gui_restore_after_callback), NULL); g_signal_connect (gimp, "exit", G_CALLBACK (gui_exit_callback), NULL); g_signal_connect_after (gimp, "exit", G_CALLBACK (gui_exit_after_callback), NULL); return status_callback; }
int ui_init( int *argc, char ***argv ) { GtkWidget *box, *menu_bar; GtkAccelGroup *accel_group; GtkSettings *settings; gtk_init(argc,argv); gdk_rgb_init(); gdk_rgb_set_install( TRUE ); gtk_widget_set_default_colormap( gdk_rgb_get_cmap() ); gtk_widget_set_default_visual( gdk_rgb_get_visual() ); gtkui_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); settings = gtk_widget_get_settings( GTK_WIDGET( gtkui_window ) ); g_object_set( settings, "gtk-menu-bar-accel", "F1", NULL ); gtk_window_set_title( GTK_WINDOW(gtkui_window), "Fuse" ); gtk_window_set_wmclass( GTK_WINDOW(gtkui_window), fuse_progname, "Fuse" ); gtk_signal_connect(GTK_OBJECT(gtkui_window), "delete-event", GTK_SIGNAL_FUNC(gtkui_delete), NULL); gtk_signal_connect(GTK_OBJECT(gtkui_window), "key-press-event", GTK_SIGNAL_FUNC(gtkkeyboard_keypress), NULL); gtk_widget_add_events( gtkui_window, GDK_KEY_RELEASE_MASK ); gtk_signal_connect(GTK_OBJECT(gtkui_window), "key-release-event", GTK_SIGNAL_FUNC(gtkkeyboard_keyrelease), NULL); /* If we lose the focus, disable all keys */ gtk_signal_connect( GTK_OBJECT( gtkui_window ), "focus-out-event", GTK_SIGNAL_FUNC( gtkui_lose_focus ), NULL ); gtk_signal_connect( GTK_OBJECT( gtkui_window ), "focus-in-event", GTK_SIGNAL_FUNC( gtkui_gain_focus ), NULL ); gtk_drag_dest_set( GTK_WIDGET( gtkui_window ), GTK_DEST_DEFAULT_ALL, drag_types, G_N_ELEMENTS( drag_types ), GDK_ACTION_COPY | GDK_ACTION_PRIVATE ); /* GDK_ACTION_PRIVATE alone DNW with ROX-Filer */ gtk_signal_connect( GTK_OBJECT( gtkui_window ), "drag-data-received", GTK_SIGNAL_FUNC( gtkui_drag_data_received ), NULL ); box = gtk_vbox_new( FALSE, 0 ); gtk_container_add(GTK_CONTAINER(gtkui_window), box); gtkui_make_menu( &accel_group, &menu_bar, gtkui_menu_data, gtkui_menu_data_size ); gtk_window_add_accel_group( GTK_WINDOW(gtkui_window), accel_group ); gtk_box_pack_start( GTK_BOX(box), menu_bar, FALSE, FALSE, 0 ); gtkui_drawing_area = gtk_drawing_area_new(); if(!gtkui_drawing_area) { fprintf(stderr,"%s: couldn't create drawing area at %s:%d\n", fuse_progname,__FILE__,__LINE__); return 1; } gtk_widget_add_events( GTK_WIDGET( gtkui_drawing_area ), GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK ); gtk_signal_connect( GTK_OBJECT( gtkui_drawing_area ), "motion-notify-event", GTK_SIGNAL_FUNC( gtkmouse_position ), NULL ); gtk_signal_connect( GTK_OBJECT( gtkui_drawing_area ), "button-press-event", GTK_SIGNAL_FUNC( gtkmouse_button ), NULL ); gtk_signal_connect( GTK_OBJECT( gtkui_drawing_area ), "button-release-event", GTK_SIGNAL_FUNC( gtkmouse_button ), NULL ); gtk_box_pack_start( GTK_BOX(box), gtkui_drawing_area, TRUE, TRUE, 0 ); /* Create the statusbar */ gtkstatusbar_create( GTK_BOX( box ) ); gtk_widget_show_all( gtkui_window ); gtkstatusbar_set_visibility( settings_current.statusbar ); ui_mouse_present = 1; return 0; }