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