void
tViewer::init ()
{
layout_w=NULL;
layout_m=NULL;
gc = gdk_gc_new (g_pReciteWord->window->window);
cmap = gdk_rgb_get_colormap();
}
GtkWidget*
gtk_xtbin_new (GdkWindow *parent_window, String * f)
{
GtkXtBin *xtbin;
gpointer user_data;
assert(parent_window != NULL);
xtbin = g_object_new (GTK_TYPE_XTBIN, NULL);
if (!xtbin)
return (GtkWidget*)NULL;
if (f)
fallback = f;
/* Initialize the Xt toolkit */
xtbin->parent_window = parent_window;
xt_client_init(&(xtbin->xtclient),
GDK_VISUAL_XVISUAL(gdk_rgb_get_visual()),
GDK_COLORMAP_XCOLORMAP(gdk_rgb_get_colormap()),
gdk_rgb_get_visual()->depth);
if (!xtbin->xtclient.xtdisplay) {
/* If XtOpenDisplay failed, we can't go any further.
* Bail out.
*/
#ifdef DEBUG_XTBIN
printf("gtk_xtbin_init: XtOpenDisplay() returned NULL.\n");
#endif
g_free (xtbin);
return (GtkWidget *)NULL;
}
/* Launch X event loop */
xt_client_xloop_create();
/* Build the hierachy */
xtbin->xtdisplay = xtbin->xtclient.xtdisplay;
gtk_widget_set_parent_window(GTK_WIDGET(xtbin), parent_window);
gdk_window_get_user_data(xtbin->parent_window, &user_data);
if (user_data)
gtk_container_add(GTK_CONTAINER(user_data), GTK_WIDGET(xtbin));
/* This GtkSocket has a visible window, but the Xt plug will cover this
* window. Normally GtkSockets let the X server paint their background and
* this would happen immediately (before the plug is mapped). Setting the
* background to None prevents the server from painting this window,
* avoiding flicker.
*/
gtk_widget_realize(GTK_WIDGET(xtbin));
gdk_window_set_back_pixmap(GTK_WIDGET(xtbin)->window, NULL, FALSE);
return GTK_WIDGET (xtbin);
}
/**
* gdk_pixbuf_render_pixmap_and_mask:
* @pixbuf: A pixbuf.
* @pixmap_return: Location to store a pointer to the created pixmap,
* or %NULL if the pixmap is not needed.
* @mask_return: Location to store a pointer to the created mask,
* or %NULL if the mask is not needed.
* @alpha_threshold: Threshold value for opacity values.
*
* Creates a pixmap and a mask bitmap which are returned in the @pixmap_return
* and @mask_return arguments, respectively, and renders a pixbuf and its
* corresponding thresholded alpha mask to them. This is merely a convenience
* function; applications that need to render pixbufs with dither offsets or to
* given drawables should use gdk_draw_pixbuf() and gdk_pixbuf_render_threshold_alpha().
*
* The pixmap that is created is created for the colormap returned
* by gdk_rgb_get_colormap(). You normally will want to instead use
* the actual colormap for a widget, and use
* gdk_pixbuf_render_pixmap_and_mask_for_colormap().
*
* If the pixbuf does not have an alpha channel, then *@mask_return will be set
* to %NULL.
**/
void
gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf,
GdkPixmap **pixmap_return,
GdkBitmap **mask_return,
int alpha_threshold)
{
gdk_pixbuf_render_pixmap_and_mask_for_colormap (pixbuf,
gdk_rgb_get_colormap (),
pixmap_return, mask_return,
alpha_threshold);
}
static void do_gtkdisplay(void)
{
GIOChannel *chan;
struct imgrect *ir;
/* have our main loop poll the pipe file descriptor */
chan = g_io_channel_unix_new(imgpipe_readfd);
g_io_add_watch(chan, G_IO_IN | G_IO_ERR | G_IO_HUP, (GIOFunc)pipe_event, NULL);
fcntl(imgpipe_readfd, F_SETFL, O_NONBLOCK);
/* set up list of image rectangles. */
imgrects = xcalloc(nimgrects = 16, sizeof *imgrects);
/* do some init thing */
gtk_init(0, NULL);
gtk_widget_push_colormap(gdk_rgb_get_colormap());
/* Make our own window. */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window, DEFAULT_WIDTH + 2 * BORDER, DEFAULT_HEIGHT + 2 * BORDER);
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);
g_signal_connect(G_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(delete_event), NULL);
g_signal_connect(G_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(destroy), NULL);
g_signal_connect(G_OBJECT(darea), "expose-event", GTK_SIGNAL_FUNC(expose_event), NULL);
g_signal_connect(G_OBJECT(darea), "configure_event", GTK_SIGNAL_FUNC(expose_event), NULL);
/* mouse button press/release for saving images */
g_signal_connect(G_OBJECT(darea), "button_press_event", GTK_SIGNAL_FUNC(button_press_event), NULL);
g_signal_connect(G_OBJECT(darea), "button_release_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);
img_delete(backing_image);
gtk_exit(0);
return; /* NOTREACHED */
}
static inline void update_skymap()
{
int i;
U1 color;
svinfo_channel_t *sv;
memset(hash, 0, sizeof(hash));
for (i=0; i<g_gpsdata.sv_channel_count; i++) {
sv = &g_gpsdata.sv_channels[i];
color = (sv->flags & 0x01)? 0x2 : ((sv->cno > 0)? 0x1 : 0x0);
hash[i] = color | (sv->elevation << 8) | (sv->azimuth << 24);
}
if (memcmp(hash, last_hash, sizeof(hash)) == 0)
return;
memcpy(last_hash, hash, sizeof(last_hash));
int center_x = da_width >> 1;
int center_y = da_height >> 1;
int off_x = center_x - bg_image_r;
int off_y = center_y - bg_image_r;
if (g_view.sky_pixbuf) {
gdk_draw_pixbuf (g_view.pixmap, g_context.drawingarea_bggc, g_view.sky_pixbuf,
0, 0, off_x, off_y, bg_image_d, bg_image_d, GDK_RGB_DITHER_NONE, -1, -1);
draw_skymap_fg(g_view.pixmap);
gdk_draw_drawable (skymap_da->window, g_context.drawingarea_bggc, g_view.pixmap,
off_x, off_y, off_x, off_y, bg_image_d, bg_image_d);
} else {
gdk_draw_rectangle (skymap_da->window, skymap_da->style->bg_gc[GTK_STATE_NORMAL], TRUE, 0, 0, da_width, da_height);
gdk_draw_line(skymap_da->window, g_context.grid_line_gc, off_x, center_y, da_width - off_x, center_y);
gdk_draw_line(skymap_da->window, g_context.grid_line_gc, center_x, off_y, center_x, da_height - off_y);
int d;
int R = bg_image_r - (EDGE >> 1);
for (i=1; i<=9; i++) {
d = R * i / 9.0;
gdk_draw_arc(skymap_da->window, g_context.grid_line_gc, FALSE,
center_x - d, center_y - d, d << 1, d << 1, 0, CIRCLE_ARC);
}
g_view.sky_pixbuf = gdk_pixbuf_get_from_drawable (NULL, g_view.pixmap,
gdk_rgb_get_colormap(), 0, 0, 0, 0, bg_image_d, bg_image_d);
draw_skymap_fg(skymap_da->window);
}
}
void pixmaps_init(void)
{
if(pixmap_cache) return;
gtk_widget_push_colormap(gdk_rgb_get_colormap());
pixmap_cache = g_fscache_new((GFSLoadFunc) image_from_file, NULL, NULL);
g_timeout_add(10000, purge, NULL);
/*
GtkIconFactory *factory;
int i;
factory = gtk_icon_factory_new();
for (i = 0; i < G_N_ELEMENTS(stocks); i++)
{
GdkPixbuf *pixbuf;
GError *error = NULL;
gchar *path;
GtkIconSet *iset;
const gchar *name = stocks[i];
path = g_strconcat(app_dir, "/images/", name, ".png", NULL);
pixbuf = gdk_pixbuf_new_from_file(path, &error);
if (!pixbuf)
{
g_warning("%s", error->message);
g_error_free(error);
pixbuf = gdk_pixbuf_new_from_xpm_data(bad_xpm);
}
g_free(path);
iset = gtk_icon_set_new_from_pixbuf(pixbuf);
g_object_unref(G_OBJECT(pixbuf));
gtk_icon_factory_add(factory, name, iset);
gtk_icon_set_unref(iset);
}
gtk_icon_factory_add_default(factory);
*/
mount_icon_size = gtk_icon_size_register("rox-mount-size", 14, 14);
load_default_pixmaps();
//option_register_widget("thumbs-purge-cache", thumbs_purge_cache);
}
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;
}
static void
read_color (GConfClient *client, const char *key, GdkColor *color)
{
gchar *tmp;
tmp = gconf_client_get_string (client, key, NULL);
if (tmp != NULL) {
if (!gdk_color_parse (tmp, color))
gdk_color_parse ("black", color);
g_free (tmp);
}
else {
gdk_color_parse ("black", color);
}
gdk_rgb_find_color (gdk_rgb_get_colormap (), color);
}
static void
mate_icon_text_item_render (MateCanvasItem *item, MateCanvasBuf *buffer)
{
GdkVisual *visual;
GdkPixmap *pixmap;
GdkPixbuf *text_pixbuf;
double affine[6];
int width, height;
visual = gdk_rgb_get_visual ();
art_affine_identity(affine);
width = ROUND (item->x2 - item->x1);
height = ROUND (item->y2 - item->y1);
pixmap = gdk_pixmap_new (NULL, width, height, visual->depth);
gdk_draw_rectangle (pixmap, GTK_WIDGET (item->canvas)->style->white_gc,
TRUE,
0, 0,
width,
height);
/* use a common routine to draw the label into the pixmap */
mate_icon_text_item_draw (item, pixmap,
ROUND (item->x1), ROUND (item->y1),
width, height);
/* turn it into a pixbuf */
text_pixbuf = gdk_pixbuf_get_from_drawable
(NULL, pixmap, gdk_rgb_get_colormap (),
0, 0,
0, 0,
width,
height);
/* draw the pixbuf containing the label */
draw_pixbuf_aa (text_pixbuf, buffer, affine, ROUND (item->x1), ROUND (item->y1));
g_object_unref (text_pixbuf);
buffer->is_bg = FALSE;
buffer->is_buf = TRUE;
}
/* Realize handler for the image view */
static void
image_view_realize (GtkWidget *widget)
{
GdkWindowAttr attr;
int attr_mask;
GdkCursor *cursor;
g_return_if_fail (widget != NULL);
g_return_if_fail (IS_IMAGE_VIEW (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
attr.window_type = GDK_WINDOW_CHILD;
attr.x = widget->allocation.x;
attr.y = widget->allocation.y;
attr.width = widget->allocation.width;
attr.height = widget->allocation.height;
attr.wclass = GDK_INPUT_OUTPUT;
attr.visual = gdk_rgb_get_visual ();
attr.colormap = gdk_rgb_get_colormap ();
attr.event_mask = (gtk_widget_get_events (widget)
| GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_SCROLL_MASK
| GDK_KEY_PRESS_MASK);
attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attr, attr_mask);
gdk_window_set_user_data (widget->window, widget);
cursor = cursor_get (widget, CURSOR_HAND_OPEN);
gdk_window_set_cursor (widget->window, cursor);
gdk_cursor_unref (cursor);
widget->style = gtk_style_attach (widget->style, widget->window);
gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
}
static gboolean skymap_da_configure_event (GtkWidget *widget, GdkEventConfigure *evt, gpointer data)
{
da_width = evt->width;
da_height = evt->height;
#ifndef ICONDIR
#define ICONDIR "/usr/share/pixmaps/omgps/"
#endif
if (g_view.sky_pixbuf) {
g_object_unref(g_view.sky_pixbuf);
g_view.sky_pixbuf = NULL;
}
GError *error = NULL;
char *file = ICONDIR"/sky.png";
/* slightly enlarge the bg image, because fg SV's can be drawn out of biggest circle. */
if (g_view.sky_pixbuf)
g_object_unref(g_view.sky_pixbuf);
int d;
g_view.sky_pixbuf = gdk_pixbuf_new_from_file_at_scale(file, da_width - EDGE, da_height - EDGE, TRUE, &error);
bg_image_d = MIN(da_width, da_height);
bg_image_r = bg_image_d >> 1;
if (g_view.sky_pixbuf) {
d = gdk_pixbuf_get_width(g_view.sky_pixbuf);
int off_x = (da_width - d) >> 1;
int off_y = (da_height - d) >> 1;
gdk_draw_rectangle (g_view.pixmap, skymap_da->style->bg_gc[GTK_STATE_NORMAL], TRUE, 0, 0, da_width, da_height);
gdk_draw_pixbuf (g_view.pixmap, g_context.drawingarea_bggc, g_view.sky_pixbuf,
0, 0, off_x, off_y, d, d, GDK_RGB_DITHER_NONE, -1, -1);
g_object_unref(g_view.sky_pixbuf);
off_x = (da_width - bg_image_d) >> 1;
off_y = (da_height - bg_image_d) >> 1;
g_view.sky_pixbuf = gdk_pixbuf_get_from_drawable (NULL, g_view.pixmap,
gdk_rgb_get_colormap(), off_x, off_y, 0, 0, bg_image_d, bg_image_d);
}
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;
}
GtkWidget*
gtk_xtbin_new (GdkWindow *parent_window, String * f)
{
GtkXtBin *xtbin;
gpointer user_data;
assert(parent_window != NULL);
xtbin = g_object_new (GTK_TYPE_XTBIN, NULL);
if (!xtbin)
return (GtkWidget*)NULL;
if (f)
fallback = f;
/* Initialize the Xt toolkit */
xtbin->parent_window = parent_window;
xt_client_init(&(xtbin->xtclient),
GDK_VISUAL_XVISUAL(gdk_rgb_get_visual()),
GDK_COLORMAP_XCOLORMAP(gdk_rgb_get_colormap()),
gdk_rgb_get_visual()->depth);
if (!xtbin->xtclient.xtdisplay) {
/* If XtOpenDisplay failed, we can't go any further.
* Bail out.
*/
#ifdef DEBUG_XTBIN
printf("gtk_xtbin_init: XtOpenDisplay() returned NULL.\n");
#endif
g_free (xtbin);
return (GtkWidget *)NULL;
}
/* If this is the first running widget, hook this display into the
mainloop */
if (0 == num_widgets) {
int cnumber;
/*
* hook Xt event loop into the glib event loop.
*/
/* the assumption is that gtk_init has already been called */
GSource* gs = g_source_new(&xt_event_funcs, sizeof(GSource));
if (!gs) {
return NULL;
}
g_source_set_priority(gs, GDK_PRIORITY_EVENTS);
g_source_set_can_recurse(gs, TRUE);
tag = g_source_attach(gs, (GMainContext*)NULL);
#ifdef VMS
cnumber = XConnectionNumber(xtdisplay);
#else
cnumber = ConnectionNumber(xtdisplay);
#endif
xt_event_poll_fd.fd = cnumber;
xt_event_poll_fd.events = G_IO_IN;
xt_event_poll_fd.revents = 0; /* hmm... is this correct? */
g_main_context_add_poll ((GMainContext*)NULL,
&xt_event_poll_fd,
G_PRIORITY_LOW);
/* add a timer so that we can poll and process Xt timers */
xt_polling_timer_id =
g_timeout_add(25,
(GtkFunction)xt_event_polling_timer_callback,
xtdisplay);
}
/* Bump up our usage count */
num_widgets++;
/* Build the hierachy */
xtbin->xtdisplay = xtbin->xtclient.xtdisplay;
gtk_widget_set_parent_window(GTK_WIDGET(xtbin), parent_window);
gdk_window_get_user_data(xtbin->parent_window, &user_data);
if (user_data)
gtk_container_add(GTK_CONTAINER(user_data), GTK_WIDGET(xtbin));
/* This GtkSocket has a visible window, but the Xt plug will cover this
* window. Normally GtkSockets let the X server paint their background and
* this would happen immediately (before the plug is mapped). Setting the
* background to None prevents the server from painting this window,
* avoiding flicker.
*/
gtk_widget_realize(GTK_WIDGET(xtbin));
gdk_window_set_back_pixmap(GTK_WIDGET(xtbin)->window, NULL, FALSE);
return GTK_WIDGET (xtbin);
}
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
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 ();
}
static void setup_font_sample(GtkWidget* darea, Antialiasing antialiasing, Hinting hinting)
{
const char* string1 = "abcfgop AO ";
const char* string2 = "abcfgop";
XftColor black, white;
XRenderColor rendcolor;
Display* xdisplay = gdk_x11_get_default_xdisplay();
#if GTK_CHECK_VERSION (3, 0, 0)
Colormap xcolormap = DefaultColormap(xdisplay, 0);
#else
GdkColormap* colormap = gdk_rgb_get_colormap();
Colormap xcolormap = GDK_COLORMAP_XCOLORMAP(colormap);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
GdkVisual* visual = gdk_visual_get_system ();
#else
GdkVisual* visual = gdk_colormap_get_visual(colormap);
#endif
Visual* xvisual = GDK_VISUAL_XVISUAL(visual);
FcPattern* pattern;
XftFont* font1;
XftFont* font2;
XGlyphInfo extents1 = { 0 };
XGlyphInfo extents2 = { 0 };
#if !GTK_CHECK_VERSION (3, 0, 0)
GdkPixmap* pixmap;
#endif
XftDraw* draw;
GdkPixbuf* tmp_pixbuf;
GdkPixbuf* pixbuf;
int width, height;
int ascent, descent;
pattern = FcPatternBuild (NULL,
FC_FAMILY, FcTypeString, "Serif",
FC_SLANT, FcTypeInteger, FC_SLANT_ROMAN,
FC_SIZE, FcTypeDouble, 18.,
NULL);
font1 = open_pattern (pattern, antialiasing, hinting);
FcPatternDestroy (pattern);
pattern = FcPatternBuild (NULL,
FC_FAMILY, FcTypeString, "Serif",
FC_SLANT, FcTypeInteger, FC_SLANT_ITALIC,
FC_SIZE, FcTypeDouble, 20.,
NULL);
font2 = open_pattern (pattern, antialiasing, hinting);
FcPatternDestroy (pattern);
ascent = 0;
descent = 0;
if (font1)
{
XftTextExtentsUtf8 (xdisplay, font1, (unsigned char*) string1,
strlen (string1), &extents1);
ascent = MAX (ascent, font1->ascent);
descent = MAX (descent, font1->descent);
}
if (font2)
{
XftTextExtentsUtf8 (xdisplay, font2, (unsigned char*) string2, strlen (string2), &extents2);
ascent = MAX (ascent, font2->ascent);
descent = MAX (descent, font2->descent);
}
width = extents1.xOff + extents2.xOff + 4;
height = ascent + descent + 2;
#if !GTK_CHECK_VERSION (3, 0, 0)
pixmap = gdk_pixmap_new (NULL, width, height, visual->depth);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
draw = XftDrawCreate (xdisplay, GDK_WINDOW_XID (gdk_screen_get_root_window (gdk_screen_get_default ())), xvisual, xcolormap);
#else
draw = XftDrawCreate (xdisplay, GDK_DRAWABLE_XID (pixmap), xvisual, xcolormap);
#endif
rendcolor.red = 0;
rendcolor.green = 0;
rendcolor.blue = 0;
rendcolor.alpha = 0xffff;
XftColorAllocValue(xdisplay, xvisual, xcolormap, &rendcolor, &black);
rendcolor.red = 0xffff;
rendcolor.green = 0xffff;
rendcolor.blue = 0xffff;
rendcolor.alpha = 0xffff;
XftColorAllocValue(xdisplay, xvisual, xcolormap, &rendcolor, &white);
XftDrawRect(draw, &white, 0, 0, width, height);
if (font1)
{
XftDrawStringUtf8(draw, &black, font1, 2, 2 + ascent, (unsigned char*) string1, strlen(string1));
}
if (font2)
{
XftDrawStringUtf8(draw, &black, font2, 2 + extents1.xOff, 2 + ascent, (unsigned char*) string2, strlen(string2));
}
XftDrawDestroy(draw);
if (font1)
{
XftFontClose(xdisplay, font1);
}
if (font2)
{
XftFontClose(xdisplay, font2);
}
#if GTK_CHECK_VERSION (3, 0, 0)
tmp_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE,8, width, height);
#else
tmp_pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, colormap, 0, 0, 0, 0, width, height);
#endif
pixbuf = gdk_pixbuf_scale_simple(tmp_pixbuf, 1 * width, 1 * height, GDK_INTERP_TILES);
#if !GTK_CHECK_VERSION (3, 0, 0)
g_object_unref(pixmap);
#endif
g_object_unref(tmp_pixbuf);
g_object_set_data_full(G_OBJECT(darea), "sample-pixbuf", pixbuf, (GDestroyNotify) g_object_unref);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_size_request (GTK_WIDGET(darea), width + 2, height + 2);
g_signal_connect(darea, "draw", G_CALLBACK(sample_draw), NULL);
#else
g_signal_connect(darea, "size_request", G_CALLBACK(sample_size_request), NULL);
g_signal_connect(darea, "expose_event", G_CALLBACK(sample_expose), NULL);
#endif
}
void
testcase_exercise (Testcase* self)
{
guchar * gdkdata;
guchar * cairodata;
gsize index;
GdkPixbuf* gdk_pixbuf;
GdkPixbuf* cairo_pixbuf;
cairo_t* cr;
g_return_if_fail (IS_TESTCASE (self));
g_signal_emit (self,
testcase_signals[EXERCISE_GDK],
0,
PRIV(self)->gdk_pixmap,
PRIV(self)->gdk_gc);
cr = gdk_cairo_create (PRIV(self)->cairo_pixmap);
g_signal_emit (self,
testcase_signals[EXERCISE_CAIRO],
0,
cr,
PRIV(self)->cairo_gc);
cairo_destroy (cr);
gdk_pixbuf = gdk_pixbuf_get_from_drawable (NULL,
PRIV(self)->gdk_pixmap,
gdk_rgb_get_colormap (),
0, 0,
0, 0,
100, 80);
cairo_pixbuf = gdk_pixbuf_get_from_drawable (NULL,
PRIV(self)->cairo_pixmap,
gdk_rgb_get_colormap (),
0, 0,
0, 0,
100, 80);
gdkdata = gdk_pixbuf_get_pixels (gdk_pixbuf);
cairodata = gdk_pixbuf_get_pixels (cairo_pixbuf);
g_return_if_fail (gdk_pixbuf_get_rowstride (gdk_pixbuf) == gdk_pixbuf_get_rowstride (cairo_pixbuf));
g_return_if_fail (gdk_pixbuf_get_n_channels (gdk_pixbuf) == gdk_pixbuf_get_n_channels (cairo_pixbuf));
g_return_if_fail (gdk_pixbuf_get_height (gdk_pixbuf) == gdk_pixbuf_get_height (cairo_pixbuf));
g_return_if_fail (gdk_pixbuf_get_width (gdk_pixbuf) == gdk_pixbuf_get_width (cairo_pixbuf));
PRIV(self)->passed = TRUE;
for (index = 0; index < gdk_pixbuf_get_height (gdk_pixbuf) * gdk_pixbuf_get_rowstride (gdk_pixbuf); index++) {
if (gdkdata[index] != cairodata[index]) {
gchar* filepath;
g_warning ("Eeek! Differences at byte %d: %c vs. %c",
index,
gdkdata[index],
cairodata[index]);
PRIV(self)->passed = FALSE;
filepath = g_strdup_printf ("%s-gdk.png",
g_get_prgname ());
gdk_pixbuf_save (gdk_pixbuf,
filepath,
"png",
NULL, /* FIXME: handle errors */
NULL);
g_message ("=> wrote gdk image to \"%s\"",
filepath);
g_free (filepath);
filepath = g_strdup_printf ("%s-cairo.png",
g_get_prgname ());
gdk_pixbuf_save (cairo_pixbuf,
filepath,
"png",
NULL, /* FIXME: handle errors */
NULL);
g_message ("=> wrote cairo image to \"%s\"",
filepath);
g_free (filepath);
break;
}
}
g_object_unref (gdk_pixbuf);
g_object_unref (cairo_pixbuf);
}
