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