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