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); */ }
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; }
static TEG_STATUS canvas_create_map( void ) { char *filename; GnomeCanvasGroup* root; GdkPixbuf *im; GnomeCanvasItem *image; gtk_widget_push_colormap (gdk_rgb_get_cmap ()); canvas_map = gnome_canvas_new (); root = gnome_canvas_root(GNOME_CANVAS(canvas_map)); filename = theme_load_file( gui_theme.board ); im = gdk_pixbuf_new_from_file(filename, NULL); if (im){ image = gnome_canvas_item_new ( root, gnome_canvas_pixbuf_get_type (), "pixbuf", im, "x", 0.0, "y", 0.0, "width", (double) gdk_pixbuf_get_width(im), "height", (double) gdk_pixbuf_get_height(im), "anchor", GTK_ANCHOR_NW, NULL); canvas_create_countries(root); armies_init(root); dices_init(root); gnome_canvas_set_scroll_region(GNOME_CANVAS(canvas_map),0,0,gdk_pixbuf_get_width(im),gdk_pixbuf_get_height(im)); gdk_pixbuf_unref(im); } else { g_warning (_("Could not find the %s file"),gui_theme.board); return TEG_STATUS_ERROR; } gtk_widget_pop_colormap (); gtk_widget_pop_visual (); return TEG_STATUS_SUCCESS; }
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); }
/** * Basic (i.e. minimal) initialization of libdia. * * It does not load any plug-ins but instead brings libdia to a state that plug-in loading can take place. * @param flags a set of DIA_INTERACTIVE, DIA_MESSAGE_STDERR */ void libdia_init (guint flags) { static gboolean initialized = FALSE; if (initialized) return; if (flags & DIA_MESSAGE_STDERR) set_message_func(stderr_message_internal); LIBXML_TEST_VERSION; #ifdef G_OS_WIN32 xmlSetGenericErrorFunc(NULL, myXmlErrorReporting); #endif if (flags & DIA_VERBOSE) { dia_log_message_enable (TRUE); dia_log_message ("initializing libdia"); } stdprops_init(); if (flags & DIA_INTERACTIVE) { char *diagtkrc; gtk_widget_set_default_colormap(gdk_rgb_get_cmap()); diagtkrc = dia_config_filename("diagtkrc"); dia_log_message ("Config from %s", diagtkrc); gtk_rc_parse(diagtkrc); g_free(diagtkrc); color_init(); } initialized = TRUE; object_registry_init(); /* The group_type is registered in app, but it needs to be exported anyway */ object_register_type(&stdpath_type); }
int main (int argc, char *argv[]) { /* a pointer to a window object - this is what we will draw on. */ GdkWindow *window; /* a set of "attributes" for our windows. This struct holds things * like width, height etc. */ GdkWindowAttr attributes; /* a bitmask of the attributes you actually want to read out of the * attributes thing above */ gint attributes_mask; /* GDK apps need a main loop to wait for events and so forth. This main * loop has a struct which tells you about it called "GMainLoop". We need * one of them. */ GMainLoop *mainloop; /* initialise gdk. We pass in argc and argv - it uses them for info like * display on X and so forth. Die if GDK can't initialize. * * Always initialise gdk before working with it. Stuff breaks otherwise. */ if (!gdk_init_check (&argc, &argv)) { return FALSE; } /* gdk_rgb_init() is a function which I can only guess sets up the * true colour colour map. It returns void so we can't check its * return value. */ gdk_rgb_init(); /* set the attributes for the window. Lets create a 400x400 top-level * window. */ attributes.window_type = GDK_WINDOW_TOPLEVEL; attributes.width = 400; attributes.height = 400; attributes.wclass = GDK_INPUT_OUTPUT; /* Get a true-colour colour map. GDK also supports indexed colour maps * but they aren't so interesting for us. */ attributes.colormap = gdk_rgb_get_cmap (); /* set our mask so that the "colormap" element is used. */ attributes_mask = GDK_WA_COLORMAP; /* create the window. */ window = gdk_window_new (NULL, &attributes, attributes_mask); /* show the window. */ gdk_window_show (window); /* Create a new main loop object. The True is to say that the structure * should be initialised to say that it is running. */ mainloop = g_main_new (TRUE); /* Run that main loop */ g_main_run (mainloop); }
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[]) { DVDResult_t res; char *msgq_str; program_name = argv[0]; #ifdef ENABLE_NLS setlocale(LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); #endif if(argc==1) { fprintf(stderr, "Error: Do not start ogle_gui directly. Start ogle\n"); exit(1); } if(pipe(dvdpipe)) { FATAL("dvdpipe: %s", strerror(errno)); exit(1); } msgq_str = argv[2]; init_interpret_config(program_name, add_keybinding, set_dvd_path); interpret_config(); gtk_init(&argc, &argv); dvdpipe_handler_id = gtk_input_add_full(dvdpipe[0], GDK_INPUT_READ, dvdpipe_handler, NULL, NULL, NULL); // Make Solaris 8+24 displays work gdk_rgb_init(); gtk_widget_set_default_colormap(gdk_rgb_get_cmap()); gtk_widget_set_default_visual(gdk_rgb_get_visual()); // Initialize glade, and read in the glade file my_glade_setup(); res = DVDOpenNav(&nav, msgq_str); if(res != DVD_E_Ok ) { DVDPerror("DVDOpen", res); exit(1); } xsniff_init(msgq_str); audio_menu_new(); subpicture_menu_new(); app = get_glade_widget("app"); gtk_widget_show(app); menu_new(app); // If a filename is given on the command line, start immediately. if(argc == 4) { res = DVDSetDVDRoot(nav, argv[3]); if(res != DVD_E_Ok) { DVDPerror("main: DVDSetDVDRoot", res); } autoload_bookmark(); } gtk_main (); return 0; }
int main (int argc, char **argv) { int i; int found_valid = FALSE; GdkPixbufAnimation *animation; gtk_init (&argc, &argv); gdk_rgb_set_verbose (TRUE); gdk_rgb_init (); gtk_widget_set_default_colormap (gdk_rgb_get_cmap ()); gtk_widget_set_default_visual (gdk_rgb_get_visual ()); { char *tbf_readlen = getenv("TBF_READLEN"); if(tbf_readlen) readlen = atoi(tbf_readlen); } { char *tbf_bps = getenv("TBF_KBPS"); guint bps; if (tbf_bps) { bps = atoi(tbf_bps); g_print ("Simulating %d kBytes/sec\n", bps); readlen = (bps*1024)/10; } } i = 1; if (argc == 1) { g_print ("USAGE: testanimation FILE1 ...\n"); return 0; } else { for (i = 1; i < argc; i++) { animation = gdk_pixbuf_animation_new_from_file (argv[i]); if (animation) { gint i = 0; GList *listptr; for (listptr = gdk_pixbuf_animation_get_frames (animation); listptr; listptr = listptr->next) { GdkPixbufFrame *frame; GdkPixbuf *pixbuf; gchar *title; frame = listptr->data; pixbuf = gdk_pixbuf_frame_get_pixbuf (frame); title = g_strdup_printf ("Frame %d", i); g_print ("Frame %d x:%d y:%d width:%d height:%d\n", i, gdk_pixbuf_frame_get_x_offset (frame), gdk_pixbuf_frame_get_y_offset (frame), gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf)); new_testrgb_window (pixbuf, title); g_free (title); i++; } found_valid = TRUE; } } #if 0 { GtkWidget* rgb_window = NULL; ProgressFileStatus status; GdkPixbufLoader *pixbuf_loader; pixbuf_loader = gdk_pixbuf_loader_new (); status.loader = pixbuf_loader; status.rgbwin = &rgb_window; status.buf = g_malloc (readlen); gtk_signal_connect(GTK_OBJECT(pixbuf_loader), "area_prepared", GTK_SIGNAL_FUNC(progressive_prepared_callback), &rgb_window); gtk_signal_connect(GTK_OBJECT(pixbuf_loader), "area_updated", GTK_SIGNAL_FUNC(progressive_updated_callback), &rgb_window); status.imagefile = fopen (argv[1], "r"); g_assert (status.imagefile != NULL); status.readlen = readlen; status.timeout = gtk_timeout_add(100, update_timeout, &status); } #endif } if (found_valid) gtk_main (); return 0; }
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; }
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; }
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[]) { GtkWidget *window; GtkWidget *button; GtkWidget *vbox; playback_t play = { 0 }; /* Option parsing */ GError *error = NULL; GOptionContext *context; GOptionEntry entries[] = { { "input-filename", 'i', 0, G_OPTION_ARG_FILENAME, &(play.filename), "Input filename", "FILE" }, { NULL } }; context = g_option_context_new("- Firefly MV Camera Playback"); g_option_context_set_summary(context, "Replays successive frames previously recorded\n" "using dc1394-record"); g_option_context_add_main_entries (context, entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { printf( "Error: %s\n%s", error->message, g_option_context_get_help(context, TRUE, NULL)); exit(1); } if (play.filename == NULL) { printf( "Error: You must supply a filename\n%s", g_option_context_get_help(context, TRUE, NULL)); exit(2); } if (play.filename[0] == '-') { play.fp = stdin; } else { play.fp = fopen(play.filename, "rb"); } if( play.fp == NULL ) { perror("opening file"); exit(1); } // read the first frame play.total_frame_size = read_frame(&play.frame, play.fp); if (play.frame.color_coding == DC1394_COLOR_CODING_MONO8) play.show = GRAY; else if (play.frame.color_coding == DC1394_COLOR_CODING_RGB8) play.show = COLOR; else if (play.frame.color_coding == DC1394_COLOR_CODING_RAW8) play.show = FORMAT7; else { perror("invalid color coding"); exit(1); } gtk_init( &argc, &argv ); gdk_rgb_init(); gtk_widget_set_default_colormap (gdk_rgb_get_cmap()); gtk_widget_set_default_visual (gdk_rgb_get_visual()); // create window window = gtk_window_new( GTK_WINDOW_TOPLEVEL ); g_signal_connect( G_OBJECT(window), "delete_event", G_CALLBACK(delete_event), NULL ); g_signal_connect( G_OBJECT(window), "destroy", G_CALLBACK(delete_event), NULL ); gtk_container_set_border_width( GTK_CONTAINER(window), 10 ); // add widgets // vbox (VBox) vbox = gtk_vbox_new(FALSE, 10); gtk_container_add( GTK_CONTAINER(window), vbox ); // canvas (DrawingArea) play.canvas = gtk_drawing_area_new(); gtk_widget_set_size_request(play.canvas, play.frame.size[0], play.frame.size[1]); g_signal_connect (G_OBJECT (play.canvas), "expose_event", G_CALLBACK (expose_event_callback), &play); gtk_widget_set_events(play.canvas, GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK ); g_signal_connect( G_OBJECT(play.canvas), "button_press_event", G_CALLBACK(canvas_button_press), &play); gtk_box_pack_start(GTK_BOX(vbox), play.canvas, TRUE, TRUE, 0); // quit button button = gtk_button_new_with_label( "Quit" ); g_signal_connect_swapped( G_OBJECT(button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(window) ); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, TRUE, 0); // play button button = gtk_button_new_with_label( "Play" ); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (on_play_clicked_event), (gpointer) &play); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, TRUE, 0); // display everything gtk_widget_show_all( window ); // render the first frame renderframe(0, &play); // go gtk_main(); fclose(play.fp); return 0; }
int gnoclCanvasCmd( ClientData data, Tcl_Interp *interp, int objc, Tcl_Obj * const objv[] ) { CanvasParams *para; int ret; if( gnoclParseOptions( interp, objc, objv, canvasOptions ) != TCL_OK ) { gnoclClearOptions( canvasOptions ); return TCL_ERROR; } para = g_new( CanvasParams, 1 ); /* what is that for? Found in canvas demos. */ gtk_widget_push_colormap( gdk_rgb_get_cmap() ); /* antialiased is default */ if( canvasOptions[antialiasedIdx].status == GNOCL_STATUS_CHANGED && canvasOptions[antialiasedIdx].val.b == 0 ) { para->canvas = GNOME_CANVAS( gnome_canvas_new( ) ); } else para->canvas = GNOME_CANVAS( gnome_canvas_new_aa( ) ); gtk_widget_show( GTK_WIDGET( para->canvas ) ); /* TODO: what is that for? Found in canvas demos. gtk_widget_pop_colormap(); */ gnome_canvas_set_center_scroll_region( para->canvas, 0 ); ret = gnoclSetOptions( interp, canvasOptions, G_OBJECT( para->canvas ), -1 ); if( ret == TCL_OK ) ret = configure( interp, para, canvasOptions ); gnoclClearOptions( canvasOptions ); if( ret != TCL_OK ) { gtk_widget_destroy( GTK_WIDGET( para->canvas ) ); g_free( para ); return TCL_ERROR; } para->name = gnoclGetAutoWidgetId(); gnoclMemNameAndWidget( para->name, GTK_WIDGET( para->canvas ) ); /* TODO: g_hash_table_new_full */ para->tagToItems = g_hash_table_new_full( g_str_hash, g_str_equal, g_free, ptrArrayFree ); para->interp = interp; g_signal_connect_after( G_OBJECT( para->canvas ), "destroy", G_CALLBACK( destroyFunc ), para ); Tcl_CreateObjCommand( interp, para->name, canvasFunc, para, NULL ); Tcl_SetObjResult( interp, Tcl_NewStringObj( para->name, -1 ) ); return TCL_OK; }
void multi_cols_test (void) { GtkWidget *canvas, *window; ETableModel *e_table_model; ETableHeader *e_table_header, *e_table_header_multiple; ETableCol *col_0, *col_1; ECell *cell_left_just, *cell_image_toggle; GnomeCanvasItem *item; gtk_widget_push_colormap (gdk_rgb_get_cmap ()); e_table_model = e_table_simple_new ( col_count, row_count, value_at, set_value_at, is_cell_editable, duplicate_value, free_value, initialize_value, value_is_empty, value_to_string, NULL); /* * Header */ e_table_header = e_table_header_new (); cell_left_just = e_cell_text_new (e_table_model, NULL, GTK_JUSTIFY_LEFT); { GdkPixbuf **images = g_new (GdkPixbuf *, 3); int i; images [0] = gdk_pixbuf_new_from_file ("image1.png"); images [1] = gdk_pixbuf_new_from_file ("image2.png"); images [2] = gdk_pixbuf_new_from_file ("image3.png"); cell_image_toggle = e_cell_toggle_new (0, 3, images); for (i = 0; i < 3; i++) gdk_pixbuf_unref (images [i]); g_free (images); } col_1 = e_table_col_new (1, "Item Name", 1.0, 20, cell_left_just, e_str_compare, TRUE); e_table_header_add_column (e_table_header, col_1, 0); col_0 = e_table_col_new (0, "A", 0.0, 48, cell_image_toggle, e_int_compare, TRUE); e_table_header_add_column (e_table_header, col_0, 1); /* * Second test */ e_table_header_multiple = e_table_header_new (); e_table_header_add_column (e_table_header_multiple, col_0, 0); e_table_header_add_column (e_table_header_multiple, col_1, 1); e_table_header_add_column (e_table_header_multiple, col_1, 2); /* * GUI */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); canvas = e_canvas_new (); g_signal_connect (canvas, "size_allocate", G_CALLBACK (set_canvas_size), NULL); gtk_container_add (GTK_CONTAINER (window), canvas); gtk_widget_show_all (window); gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), e_table_header_item_get_type (), "ETableHeader", e_table_header, NULL); item = gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), e_table_item_get_type (), "ETableHeader", e_table_header, "ETableModel", e_table_model, "drawgrid", TRUE, "drawfocus", TRUE, "cursor_mode", E_TABLE_CURSOR_SIMPLE, #if 0 "spreadsheet", TRUE, #endif NULL); e_canvas_item_move_absolute (item, 0, 30); gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), e_table_header_item_get_type (), "ETableHeader", e_table_header_multiple, NULL); item = gnome_canvas_item_new ( gnome_canvas_root (GNOME_CANVAS (canvas)), e_table_item_get_type (), "ETableHeader", e_table_header_multiple, "ETableModel", e_table_model, "drawgrid", TRUE, "drawfocus", TRUE, #if 0 "spreadsheet", TRUE, #endif "cursor_mode", E_TABLE_CURSOR_SIMPLE, NULL); e_canvas_item_move_absolute (item, 300, 30); }