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);
}
static void sanalyzer_init(void)
{
GdkColor color;
int i;
if(window)
return;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(window),_("Spectrum analyzer"));
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_widget_realize(window);
bg_pixmap = gdk_pixmap_create_from_xpm_d(window->window,NULL,NULL,sanalyzer_xmms_logo_xpm);
gdk_window_set_back_pixmap(window->window,bg_pixmap,0);
gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(sanalyzer_destroy_cb),NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
gtk_widget_set_usize(window, WIDTH, HEIGHT);
gc = gdk_gc_new(window->window);
draw_pixmap = gdk_pixmap_new(window->window,WIDTH,HEIGHT,gdk_rgb_get_visual()->depth);
bar = gdk_pixmap_new(window->window,25, HEIGHT, gdk_rgb_get_visual()->depth);
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = 0xFFFF;
color.green = ((i * 255) / (HEIGHT / 2)) << 8;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i,24,i);
}
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = (255 - ((i * 255) / (HEIGHT / 2))) <<8;
color.green = 0xFFFF;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i + (HEIGHT / 2),24,i + (HEIGHT / 2));
}
scale = HEIGHT / log(256);
gdk_color_black(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window),area);
gtk_widget_realize(area);
gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
gtk_widget_show(area);
gtk_widget_show(window);
gdk_window_clear(window->window);
gdk_window_clear(area->window);
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_initState__II
(JNIEnv *env, jobject obj, jint width, jint height)
{
struct graphics2d *gr;
gdk_threads_enter ();
gr = (struct graphics2d *) malloc (sizeof (struct graphics2d));
g_assert (gr != NULL);
memset (gr, 0, sizeof(struct graphics2d));
check_for_debug (gr);
if (gr->debug) printf ("constructing offscreen drawable of size (%d,%d)\n",
width, height);
gr->drawable = (GdkDrawable *) gdk_pixmap_new (NULL, width, height,
gdk_rgb_get_visual ()->depth);
g_assert (gr->drawable != NULL);
gr->cr = cairo_create();
g_assert (gr->cr != NULL);
if (x_server_has_render_extension ())
init_graphics2d_as_renderable (gr);
else
init_graphics2d_as_pixbuf (gr);
gdk_threads_leave ();
if (gr->debug) printf ("constructed offscreen drawable of size (%d,%d)\n",
width, height);
NSA_SET_G2D_PTR (env, obj, gr);
}
/**
* Creates a cairo surface, ARGB32, native ordering, premultiplied alpha.
*/
JNIEXPORT jlong JNICALL
Java_gnu_java_awt_peer_gtk_GtkVolatileImage_init (JNIEnv *env,
jobject obj __attribute__ ((__unused__)),
jobject peer,
jint width, jint height)
{
GtkWidget *widget = NULL;
GdkPixmap* pixmap;
void *ptr = NULL;
gdk_threads_enter();
if( peer != NULL )
{
ptr = gtkpeer_get_widget (env, peer);
g_assert (ptr != NULL);
widget = GTK_WIDGET (ptr);
g_assert (widget != NULL);
pixmap = gdk_pixmap_new( widget->window, width, height, -1 );
}
else
pixmap = gdk_pixmap_new( NULL, width, height,
gdk_rgb_get_visual()->depth );
gdk_threads_leave();
g_assert( pixmap != NULL );
return PTR_TO_JLONG( pixmap );
}
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); */
}
NS_IMETHODIMP
nsScreenGtk :: GetPixelDepth(PRInt32 *aPixelDepth)
{
GdkVisual * rgb_visual = gdk_rgb_get_visual();
*aPixelDepth = rgb_visual->depth;
return NS_OK;
} // GetPixelDepth
void nsToolkit::CreateSharedGC(void)
{
GdkPixmap *pixmap;
if (mSharedGC)
return;
pixmap = gdk_pixmap_new(NULL, 1, 1, gdk_rgb_get_visual()->depth);
mSharedGC = gdk_gc_new(pixmap);
gdk_pixmap_unref(pixmap);
}
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;
}
void
tTextButton::create (GtkWidget * pfixed, gint x, gint y, gint w, gint h,gint tx1, gint ty1,gint tx2, gint ty2,
GdkPixmap * pix_1, GdkPixmap * pix_2, gchar * str,
void (*func) (gpointer), gpointer data)
{
init ();
pix_normal = pix_1;
pix_down = pix_2;
width = w;
height = h;
text_x1 = tx1;
text_y1 = ty1;
text_x2 = tx2;
text_y2 = ty2;
runfunc = func;
funcdata = data;
draw_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (draw_area, width, height);
gtk_widget_set_events (draw_area,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK);
g_signal_connect (G_OBJECT (draw_area), "expose_event",
G_CALLBACK (on_textbutton_expose), this);
g_signal_connect (G_OBJECT (draw_area), "button_press_event",
G_CALLBACK (on_textbutton_buttonpress), this);
g_signal_connect (G_OBJECT (draw_area), "button_release_event",
G_CALLBACK (on_textbutton_buttonrelease), this);
g_signal_connect (G_OBJECT (draw_area), "enter_notify_event",
G_CALLBACK (on_textbutton_enter_notify), this);
g_signal_connect (G_OBJECT (draw_area), "leave_notify_event",
G_CALLBACK (on_textbutton_leave_notify), this);
gtk_fixed_put (GTK_FIXED (pfixed), draw_area, x, y);
gtk_widget_show (draw_area);
gdk_window_set_cursor (draw_area->window, Skin->reciteword.hand_cursor.cursor);
draw_pixmap =
gdk_pixmap_new (draw_area->window, width, height,
gdk_rgb_get_visual ()->depth);
strcpy (text, str);
layout=gtk_widget_create_pango_layout (draw_area, text);
draw (false);
}
/* 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 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;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkGraphics_initState__II
(JNIEnv *env, jobject obj, jint width, jint height)
{
struct graphics *g;
g = (struct graphics *) malloc (sizeof (struct graphics));
g->x_offset = g->y_offset = 0;
gdk_threads_enter ();
g->drawable = (GdkDrawable *) gdk_pixmap_new (NULL, width, height,
gdk_rgb_get_visual ()->depth);
g->cm = gdk_rgb_get_cmap ();
gdk_colormap_ref (g->cm);
g->gc = gdk_gc_new (g->drawable);
gdk_threads_leave ();
NSA_SET_PTR (env, obj, g);
}
void
tViewer::create (GtkWidget * pfixed, gint x, gint y, gint w, gint h,
gchar ** str_w, gchar ** str_m, gint _count, void (*func) ())
{
init ();
str_1 = str_w;
str_2 = str_m;
count = _count;
runfunc = func;
text_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (text_area, w, h);
g_signal_connect (G_OBJECT (text_area), "expose_event",
G_CALLBACK(on_viewer_expose), this);
gtk_fixed_put (GTK_FIXED (pfixed), text_area, x, y);
gtk_widget_show (text_area);
draw_pixmap =
gdk_pixmap_new (text_area->window, w, h,
gdk_rgb_get_visual ()->depth);
refresh ();
}
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;
}
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;
}
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 ();
}
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;
}
GdkSuperWin *
gdk_superwin_new (GdkWindow *parent_window,
guint x,
guint y,
guint width,
guint height)
{
GdkWindowAttr attributes;
gint attributes_mask;
Window bin_xwindow;
Display *xdisplay;
XSetWindowAttributes xattr;
unsigned long xattr_mask;
GdkSuperWin *superwin = gtk_type_new(GDK_TYPE_SUPERWIN);
superwin->translate_queue = NULL;
superwin->shell_func = NULL;
superwin->paint_func = NULL;
superwin->flush_func = NULL;
superwin->func_data = NULL;
superwin->notify = NULL;
/* Create the shell (clipping) window */
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = x;
attributes.y = y;
attributes.width = width;
attributes.height = height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.colormap = gdk_rgb_get_cmap();
attributes.visual = gdk_rgb_get_visual();
attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
attributes_mask = GDK_WA_VISUAL | GDK_WA_X | GDK_WA_Y | GDK_WA_COLORMAP;
superwin->shell_window = gdk_window_new (parent_window,
&attributes, attributes_mask);
/* set the back pixmap to None so that you don't end up with the gtk
default which is BlackPixel */
gdk_window_set_back_pixmap (superwin->shell_window, NULL, FALSE);
/* if we failed to create a window, die a horrible death */
g_assert((superwin->shell_window));
/* Create the bin window for drawing */
attributes.x = 0;
attributes.y = 0;
attributes.event_mask = GDK_EXPOSURE_MASK;
superwin->bin_window = gdk_window_new (superwin->shell_window,
&attributes, attributes_mask);
/* set the back pixmap to None so that you don't end up with the gtk
default which is BlackPixel */
gdk_window_set_back_pixmap (superwin->bin_window, NULL, FALSE);
/* set the backing store for the bin window */
bin_xwindow = GDK_WINDOW_XWINDOW(superwin->bin_window);
xdisplay = GDK_WINDOW_XDISPLAY(superwin->bin_window);
/* XXX should we make this Always? */
xattr.backing_store = WhenMapped;
xattr_mask = CWBackingStore;
/* XChangeWindowAttributes(xdisplay, bin_xwindow, xattr_mask, &xattr); */
gdk_window_show (superwin->bin_window);
gdk_window_add_filter (superwin->shell_window, gdk_superwin_shell_filter, superwin);
gdk_window_add_filter (superwin->bin_window, gdk_superwin_bin_filter, superwin);
gravity_works = gdk_window_set_static_gravities (superwin->bin_window, TRUE);
return superwin;
}
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[])
{
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;
}
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());
}
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
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;
}
