static GdkCursor *
create_cursor(GdkWindow *window,
const gchar *data, int width, int height,
const gchar *mask, int hot_x, int hot_y)
{
GdkBitmap *dbit, *mbit;
GdkColor black, white;
GdkCursor *cursor;
g_return_val_if_fail(window != NULL, NULL);
dbit = gdk_bitmap_create_from_data(window, data, width, height);
mbit = gdk_bitmap_create_from_data(window, mask, width, height);
g_assert(dbit != NULL && mbit != NULL);
gdk_color_black(gdk_window_get_colormap(window), &black);
gdk_color_white(gdk_window_get_colormap(window), &white);
cursor = gdk_cursor_new_from_pixmap(dbit, mbit, &white,&black, hot_x,hot_y);
g_assert(cursor != NULL);
gdk_bitmap_unref(dbit);
gdk_bitmap_unref(mbit);
return cursor;
}
void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
{
if (m_hasBgCol && m_backgroundColour.Ok())
{
GdkWindow *window = GTK_WIDGET(m_list)->window;
if ( window )
{
m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
}
GList *child = m_list->children;
while (child)
{
gtk_widget_modify_style( GTK_WIDGET(child->data), style );
GtkBin *bin = GTK_BIN( child->data );
GtkWidget *label = GTK_WIDGET( bin->child );
gtk_widget_modify_style( label, style );
child = child->next;
}
}
bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
{
wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
if ( !wxControl::SetBackgroundColour( colour ) )
return false;
if (!m_widget->window)
return false;
if (!m_backgroundColour.IsOk())
return false;
if (m_windowStyle & wxTE_MULTILINE)
{
GdkWindow *window = GTK_TEXT(m_text)->text_area;
if (!window)
return false;
m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
// change active background color too
m_defaultStyle.SetBackgroundColour( colour );
return true;
}
/*
* Bootstrap our UI, get our buffers, etc.
*/
int main( int argc, char* argv[] )
{
extern int nes_psg_quality; /* FIXME: cheap hack, copied from nes_psg.h */
translation_buffer_16 = NULL;
vid_pre_xlat = NULL;
timeslice = NULL;
timeslice_data = NULL;
nes_psg_quality = 2;
image_1 = image_2 = NULL;
video_buffer_1 = video_buffer_2 = NULL;
/* Get Gtk up and running. */
gtk_init( &argc, &argv );
nes_gtk_window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( nes_gtk_window ), "DarcNES" );
gtk_widget_set_usize( nes_gtk_window, 256, 240 );
gtk_signal_connect( GTK_OBJECT( nes_gtk_window ), "destroy",
GTK_SIGNAL_FUNC( destroy ), NULL );
gtk_signal_connect( GTK_OBJECT( nes_gtk_window ), "key_press_event",
GTK_SIGNAL_FUNC( key_press ), NULL );
gtk_signal_connect( GTK_OBJECT( nes_gtk_window ), "key_release_event",
GTK_SIGNAL_FUNC( key_release ), NULL );
gtk_widget_set_events( nes_gtk_window, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK );
gtk_widget_show( nes_gtk_window );
visual = gdk_window_get_visual( nes_gtk_window->window );
gc = gdk_gc_new( nes_gtk_window->window );
color_map = gdk_window_get_colormap( nes_gtk_window->window );
if( argc > 1 )
{
int system_type;
rom_file romfile;
strncpy( rom_name, argv[1], 127 );
romfile = read_romimage(rom_name);
system_type = guess_system(romfile);
activate_system(system_type, romfile);
}
else
{
show_open_dialog( NULL, NULL );
}
/* Using GTK_PRIORITY_HIGH causes Gtk events to not occur. */
gtk_idle_add( (GtkFunction) emulate_timeslice, NULL );
gtk_main( );
return 0;
}
/** Start program, do stuff, return 0 */
int main(int argc, char **argv) {
GtkWidget *w, *notebook, *vbox, *button;
signal(SIGCHLD, ignore);
at_jobs = get_at_jobs();
cron_jobs = get_cron_jobs();
if (!at_jobs || !cron_jobs) return -1;
/* print_jobs(at_jobs, cron_jobs);*/
gnome_init("gat", VERSION, argc, argv);
w = gnome_app_new("gat", "GTK Task Scheduler");
gtk_container_border_width(GTK_CONTAINER(w), 8);
gtk_signal_connect(GTK_OBJECT(w), "delete_event",
GTK_SIGNAL_FUNC(gtk_main_quit), 0);
notebook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), make_at_page(at_jobs),
gtk_label_new("One-time jobs"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), make_cron_page(cron_jobs),
gtk_label_new("Recurring jobs"));
vbox = gtk_vbox_new(FALSE, 5);
button = gtk_button_new_with_label("Close");
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit), 0);
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 5);
gnome_app_set_contents(GNOME_APP(w), vbox);
gtk_widget_show_all(w);
dark_grey.red = dark_grey.green = dark_grey.blue = 0x8000;
gdk_color_alloc(gdk_window_get_colormap(w->window), &dark_grey);
gdk_color_black(gdk_window_get_colormap(w->window), &black);
gtk_main();
return 0;
}
void allocate_quake_player_colors (GdkWindow *window) {
GdkColormap *colormap;
int i, j;
if (!pcolors_allocated) {
colormap = gdk_window_get_colormap (window);
for (i = 0; i < 14; i++) {
j = (i<8)? 11 : 15 - 11;
pcolors[i].pixel = 0;
pcolors[i].red = convert_color (quake_pallete [(i*16 + j)*3 + 0]);
pcolors[i].green = convert_color (quake_pallete [(i*16 + j)*3 + 1]);
pcolors[i].blue = convert_color (quake_pallete [(i*16 + j)*3 + 2]);
if (!gdk_color_alloc (colormap, &pcolors[i])) {
g_warning ("unable to allocate color: ( %d %d %d )",
pcolors[i].red, pcolors[i].green, pcolors[i].blue);
}
}
pcolors_allocated = TRUE;
}
}
/* grab top corner of screen to a pixmap via an intermediate pixbuf */
GdkPixmap *
grab_pixmap2()
{
GdkDrawable *src;
GdkPixmap *dest;
GdkColormap *cmap;
GdkPixbuf *pbuf;
GdkGC *gc;
dest = gdk_pixmap_new(NULL, 100, 100, 24);
src = gdk_window_lookup(gdk_x11_get_default_root_xwindow());
cmap = gdk_window_get_colormap(src);
pbuf = gdk_pixbuf_get_from_drawable(NULL, src, cmap, 0, 0, 0, 0, 100, 100);
gc = gdk_gc_new(dest);
gdk_draw_pixbuf(dest, gc, pbuf,
0, 0, 0, 0, 100, 100, 0, 0, 0);
g_object_unref(G_OBJECT(gc));
g_object_unref(G_OBJECT(pbuf));
return dest;
}
GtkWidget*
gtk_xtbin_new (GdkWindow *parent_window, String * f)
{
GtkXtBin *xtbin;
gpointer user_data;
assert(parent_window != NULL);
xtbin = gtk_type_new (GTK_TYPE_XTBIN);
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_window_get_visual(parent_window )),
GDK_COLORMAP_XCOLORMAP(gdk_window_get_colormap(parent_window)),
gdk_window_get_visual(parent_window )->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 =
gtk_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));
return GTK_WIDGET (xtbin);
}
GtkWidget*
get_viewer_toolbar(GtkWidget *parent)
{
GtkWidget *toolbar, *pixmap_wid, *button;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
gboolean fit_screen;
style = gtk_widget_get_style(parent);
toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
gtk_tooltips_set_colors(
GTK_TOOLBAR(toolbar)->tooltips,
get_viewer_tooltips_bgcolor(parent->window, gdk_window_get_colormap(parent->window)),
&style->fg[GTK_STATE_NORMAL]);
gtk_tooltips_set_delay(GTK_TOOLBAR(toolbar)->tooltips, 100);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)browse_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Browse"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_browse),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)fullscreen_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Full screen"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_full_screen),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)save_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
saveimage_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Save Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_save_image),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)prev_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
prev_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Previous Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_prev_image),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)next_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
next_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Next Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_next_image),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)slideshow_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
slideshow_button = gtk_toolbar_append_element(
GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
NULL,
NULL,
_("Stop/Resume Slideshow"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_slideshow_toggled),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)refresh_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Refresh"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_refresh),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)screen_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
button = gtk_toolbar_append_element(
GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
NULL,
NULL,
_("Fit Screen"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_fitscreen_toggled),
NULL);
fit_screen = rc_get_boolean("fit_screen");
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), fit_screen);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)rotate_left_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Rotate -90"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_rotate),
(gint *) LEFT);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)rotate_right_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Rotate +90"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_rotate),
(gint *) RIGHT);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)right_left_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Reflect Right/Left"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_reflect),
(gint *) RIGHTLEFT);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)up_down_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Reflect Up/Down"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_reflect),
(gint *) UPDOWN);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)exit_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Exit"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(close_gtksee),
NULL);
return toolbar;
}
/*!
Initialize the display size, position and title.
\param w, h : Width and height of the window.
\param x, y : The window is set at position x,y (column index, row index).
\param title : Window title.
*/
void
vpDisplayGTK::init(unsigned int w, unsigned int h,
int x, int y,
const std::string &title)
{
/* Initialisation of thegdk et gdk_rgb library */
int *argc=NULL ;
char **argv ;
gtk_init(argc,&argv);
this->width = w;
this->height = h;
/* Create the window*/
widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_add_events(widget, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK);
gtk_window_set_default_size(GTK_WINDOW(widget), (gint)width, (gint)height);
if (x != -1)
windowXPosition = x ;
if (y != -1)
windowYPosition = y ;
gtk_window_move(GTK_WINDOW(widget), windowXPosition, windowYPosition);
gtk_widget_show(widget);
gdk_rgb_init();
/* Create background pixmap */
background = gdk_pixmap_new(widget->window, (gint)width, (gint)height, -1);
/* Create graphic context */
gc = gdk_gc_new(widget->window);
/* get the colormap */
colormap = gdk_window_get_colormap(widget->window);
col = new GdkColor *[vpColor::id_unknown] ; // id_unknown = number of predefined colors
/* Create color */
gdk_color_parse("light blue",&lightBlue);
gdk_colormap_alloc_color(colormap,&lightBlue,FALSE,TRUE);
col[vpColor::id_lightBlue] = &lightBlue ;
gdk_color_parse("blue",&blue);
gdk_colormap_alloc_color(colormap,&blue,FALSE,TRUE);
col[vpColor::id_blue] = &blue ;
gdk_color_parse("dark blue",&darkBlue);
gdk_colormap_alloc_color(colormap,&darkBlue,FALSE,TRUE);
col[vpColor::id_darkBlue] = &darkBlue ;
gdk_color_parse("#FF8C8C",&lightRed);
gdk_colormap_alloc_color(colormap,&lightRed,FALSE,TRUE);
col[vpColor::id_lightRed] = &lightRed ;
gdk_color_parse("red",&red);
gdk_colormap_alloc_color(colormap,&red,FALSE,TRUE);
col[vpColor::id_red] = &red ;
gdk_color_parse("dark red",&darkRed);
gdk_colormap_alloc_color(colormap,&darkRed,FALSE,TRUE);
col[vpColor::id_darkRed] = &darkRed ;
gdk_color_parse("light green",&lightGreen);
gdk_colormap_alloc_color(colormap,&lightGreen,FALSE,TRUE);
col[vpColor::id_lightGreen] = &lightGreen ;
gdk_color_parse("green",&green);
gdk_colormap_alloc_color(colormap,&green,FALSE,TRUE);
col[vpColor::id_green] = &green ;
gdk_color_parse("dark green",&darkGreen);
gdk_colormap_alloc_color(colormap,&darkGreen,FALSE,TRUE);
col[vpColor::id_darkGreen] = &darkGreen ;
gdk_color_parse("yellow",&yellow);
gdk_colormap_alloc_color(colormap,&yellow,FALSE,TRUE);
col[vpColor::id_yellow] = &yellow ;
gdk_color_parse("cyan",&cyan);
gdk_colormap_alloc_color(colormap,&cyan,FALSE,TRUE);
col[vpColor::id_cyan] = &cyan ;
gdk_color_parse("orange",&orange);
gdk_colormap_alloc_color(colormap,&orange,FALSE,TRUE);
col[vpColor::id_orange] = &orange ;
gdk_color_parse("purple",&purple);
gdk_colormap_alloc_color(colormap,&purple,FALSE,TRUE);
col[vpColor::id_purple] = &purple ;
gdk_color_parse("white",&white);
gdk_colormap_alloc_color(colormap,&white,FALSE,TRUE);
col[vpColor::id_white] = &white ;
gdk_color_parse("black",&black);
gdk_colormap_alloc_color(colormap,&black,FALSE,TRUE);
col[vpColor::id_black] = &black ;
gdk_color_parse("#C0C0C0",&lightGray);
gdk_colormap_alloc_color(colormap,&lightGray,FALSE,TRUE);
col[vpColor::id_lightGray] = &lightGray ;
gdk_color_parse("#808080",&gray);
gdk_colormap_alloc_color(colormap,&gray,FALSE,TRUE);
col[vpColor::id_gray] = &gray ;
gdk_color_parse("#404040",&darkGray);
gdk_colormap_alloc_color(colormap,&darkGray,FALSE,TRUE);
col[vpColor::id_darkGray] = &darkGray ;
// Try to load a default font
font = gdk_font_load("-*-times-medium-r-normal-*-16-*-*-*-*-*-*-*");
if (font == NULL)
font = gdk_font_load("-*-courier-bold-r-normal-*-*-140-*-*-*-*-*-*");
if (font == NULL)
font = gdk_font_load("-*-courier 10 pitch-medium-r-normal-*-16-*-*-*-*-*-*-*");
title_ = title;
if(!title.empty())
gdk_window_set_title(widget->window, title_.c_str());
displayHasBeenInitialized = true ;
}
static GtkWidget *
create_window (int confirm_mode)
{
GtkWidget *w;
GtkWidget *win, *box, *ebox;
GtkWidget *sbox, *bbox;
GtkAccelGroup *acc;
/* fixme: check the grabbing code against the one we used with the
old gpg-agent */
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
acc = gtk_accel_group_new ();
gtk_signal_connect (GTK_OBJECT (win), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
#if 0
gtk_signal_connect (GTK_OBJECT(win), "destroy", gtk_main_quit, NULL);
#endif
gtk_signal_connect (GTK_OBJECT(win), "size-request", constrain_size, NULL);
if (!confirm_mode)
{
gtk_signal_connect (GTK_OBJECT(win),
pinentry->grab ? "map-event" : "focus-in-event",
grab_keyboard, NULL);
gtk_signal_connect (GTK_OBJECT(win),
pinentry->grab ? "unmap-event" : "focus-out-event",
ungrab_keyboard, NULL);
}
gtk_accel_group_attach(acc, GTK_OBJECT(win));
box = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER(win), box);
gtk_container_set_border_width (GTK_CONTAINER (box), 5);
if (pinentry->description)
{
w = create_utf8_label (pinentry->description);
gtk_box_pack_start (GTK_BOX(box), w, TRUE, FALSE, 0);
}
if (pinentry->error && !confirm_mode)
{
GtkStyle *style;
GdkColormap *cmap;
GdkColor color[1] = {{0, 0xffff, 0, 0}};
gboolean success[1];
w = create_utf8_label (pinentry->error);
gtk_box_pack_start (GTK_BOX(box), w, TRUE, FALSE, 5);
/* fixme: Do we need to release something, or is there a more
easy way to set a text color? */
gtk_widget_realize (win);
cmap = gdk_window_get_colormap (win->window);
assert (cmap);
gdk_colormap_alloc_colors (cmap, color, 1, FALSE, TRUE, success);
if (success[0])
{
gtk_widget_ensure_style(w);
style = gtk_style_copy(gtk_widget_get_style(w));
style->fg[GTK_STATE_NORMAL] = color[0];
gtk_widget_set_style(w, style);
}
}
ebox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX(box), ebox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (ebox), 5);
if (!confirm_mode)
{
if (pinentry->prompt)
{
w = create_utf8_label (pinentry->prompt);
gtk_box_pack_start (GTK_BOX(ebox), w, FALSE, FALSE, 0);
}
entry = gtk_secure_entry_new ();
gtk_signal_connect (GTK_OBJECT (entry), "activate",
GTK_SIGNAL_FUNC (enter_callback), entry);
gtk_box_pack_start (GTK_BOX(ebox), entry, TRUE, TRUE, 0);
gtk_secure_entry_set_visibility (GTK_SECURE_ENTRY(entry), FALSE);
gtk_signal_connect_after (GTK_OBJECT(entry), "button_press_event",
unselect, NULL);
gtk_widget_grab_focus (entry);
gtk_widget_show (entry);
if (pinentry->enhanced)
{
sbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(box), sbox, FALSE, FALSE, 0);
w = gtk_label_new ("Forget secret after");
gtk_box_pack_start(GTK_BOX(sbox), w, FALSE, FALSE, 0);
gtk_widget_show(w);
time_out = gtk_spin_button_new
(GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, HUGE_VAL,
1, 60, 60)),2,0);
gtk_box_pack_start (GTK_BOX(sbox), time_out, FALSE, FALSE, 0);
gtk_widget_show (time_out);
w = gtk_label_new ("seconds");
gtk_box_pack_start (GTK_BOX(sbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
gtk_widget_show (sbox);
insure = gtk_check_button_new_with_label
("ask before giving out secret");
gtk_box_pack_start (GTK_BOX(box), insure, FALSE, FALSE, 0);
gtk_widget_show (insure);
}
}
bbox = gtk_hbutton_box_new();
gtk_box_pack_start (GTK_BOX(box), bbox, TRUE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
w = gtk_button_new_with_label (pinentry->ok ? pinentry->ok : "OK");
gtk_container_add (GTK_CONTAINER(bbox), w);
if (!confirm_mode)
{
gtk_signal_connect (GTK_OBJECT(w), "clicked", button_clicked, "ok");
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
gtk_widget_grab_default (w);
gtk_signal_connect_object (GTK_OBJECT (entry), "focus_in_event",
GTK_SIGNAL_FUNC (gtk_widget_grab_default),
GTK_OBJECT (w));
}
else
{
gtk_signal_connect (GTK_OBJECT(w), "clicked",
confirm_button_clicked, "ok");
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
}
gtk_widget_show (w);
if (!pinentry->one_button)
{
w = gtk_button_new_with_label (pinentry->cancel
? pinentry->cancel : "Cancel");
gtk_container_add (GTK_CONTAINER(bbox), w);
gtk_accel_group_add (acc, GDK_Escape, 0, 0, GTK_OBJECT(w), "clicked");
gtk_signal_connect (GTK_OBJECT(w), "clicked",
confirm_mode? confirm_button_clicked: button_clicked,
NULL);
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
}
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_widget_show_all (win);
return win;
}
G_MODULE_EXPORT void save_as(const char *filename, int type)
{
FILE *fp;
unsigned int i, j;
double freq, k;
mat_t *mat;
matvar_t *matvar;
int dims[2];
char tmp[20];
GdkPixbuf *pixbuf;
GError *err=NULL;
GdkColormap *cmap;
gint width, height;
gboolean ret = true;
char *name;
gdouble *tmp_data;
name = malloc(strlen(filename) + 5);
switch(type) {
/* Response Codes encoded in glade file */
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CANCEL:
break;
case SAVE_VSA:
/* Allow saving data when only in Time Domanin */
if ((gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) &&
(gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != XY_PLOT)) {
create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type",
"Please make sure to set the Plot Type to \"Time Domanin\" before saving data.");
return;
}
/* Save as Agilent VSA formatted file */
if (!strncasecmp(&filename[strlen(filename)-4], ".txt", 4))
strcpy(name, filename);
else
sprintf(name, "%s.txt", filename);
fp = fopen(name, "w");
if (!fp)
break;
fprintf(fp, "InputZoom\tTRUE\n");
fprintf(fp, "InputCenter\t0\n");
fprintf(fp, "InputRange\t1\n");
fprintf(fp, "InputRefImped\t50\n");
fprintf(fp, "XStart\t0\n");
if (!strcmp(adc_scale, "M"))
freq = adc_freq * 1000000;
else if (!strcmp(adc_scale, "k"))
freq = adc_freq * 1000;
else {
printf("error in writing\n");
break;
}
fprintf(fp, "XDelta\t%-.17f\n", 1.0/freq);
fprintf(fp, "XDomain\t2\n");
fprintf(fp, "XUnit\tSec\n");
fprintf(fp, "YUnit\tV\n");
fprintf(fp, "FreqValidMax\t%e\n", freq / 2);
fprintf(fp, "FreqValidMin\t-%e\n", freq / 2);
fprintf(fp, "Y\n");
for (j = 0; j < num_samples; j++) {
for (i = 0; i < num_active_channels ; i++) {
fprintf(fp, "%g", channel_data[i][j]);
if (i < (num_active_channels - 1))
fprintf(fp, "\t");
}
fprintf(fp, "\n");
}
fprintf(fp, "\n");
fclose(fp);
break;
case SAVE_MAT:
/* Allow saving data when only in Time Domanin */
if (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) {
create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type",
"Please make sure to set the Plot Type to \"Time Domanin\" before saving data.");
return;
}
/* Matlab file
* http://na-wiki.csc.kth.se/mediawiki/index.php/MatIO
*/
if (!strncasecmp(&filename[strlen(filename)-4], ".mat", 4))
strcpy(name, filename);
else
sprintf(name, "%s.mat", filename);
dims[1] = 1;
dims[0] = num_samples;
mat = Mat_Open(name, MAT_ACC_RDWR);
if(mat) {
for (i = 0; i < num_active_channels; i++) {
sprintf(tmp, "in_voltage%d", i);
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(save_mat_scale))) {
matvar = Mat_VarCreate(tmp, MAT_C_SINGLE,
MAT_T_SINGLE, 2, dims, channel_data[i], 0);
} else {
tmp_data = g_new(gdouble, num_samples);
if (channels[i].is_signed)
k = channels[i].bits_used - 1;
else
k = channels[i].bits_used;
for (j = 0; j < num_samples; j++) {
tmp_data[j] = (gdouble)channel_data[i][j] /
(pow(2.0, k));
}
matvar = Mat_VarCreate(tmp, MAT_C_DOUBLE,
MAT_T_DOUBLE, 2, dims, tmp_data, 0);
g_free(tmp_data);
}
if (!matvar)
printf("error creating matvar on channel %i\n", i);
else {
Mat_VarWrite(mat, matvar, 0);
Mat_VarFree(matvar);
}
}
Mat_Close(mat);
}
break;
case SAVE_CSV:
/* Allow saving data when only in Time Domanin */
if (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) {
create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type",
"Please make sure to set the Plot Type to \"Time Domanin\" before saving data.");
return;
}
/* save comma seperated valus (csv) */
if (!strncasecmp(&filename[strlen(filename)-4], ".csv", 4))
strcpy(name, filename);
else
sprintf(name, "%s.csv", filename);
fp = fopen(name, "w");
if (!fp)
break;
for (j = 0; j < num_samples; j++) {
for (i = 0; i < num_active_channels ; i++) {
fprintf(fp, "%g", channel_data[i][j]);
if (i < (num_active_channels - 1))
fprintf(fp, ", ");
}
fprintf(fp, "\n");
}
fprintf(fp, "\n");
fclose(fp);
break;
case SAVE_PNG:
/* save_png */
if (!strncasecmp(&filename[strlen(filename)-4], ".png", 4))
strcpy(name, filename);
else
sprintf(name, "%s.png", filename);
cmap = gdk_window_get_colormap(
GDK_DRAWABLE(gtk_widget_get_window(capture_graph)));
gdk_drawable_get_size(GDK_DRAWABLE(gtk_widget_get_window(capture_graph)),
&width, &height);
pixbuf = gdk_pixbuf_get_from_drawable(NULL,
GDK_DRAWABLE(gtk_widget_get_window(capture_graph)),
cmap, 0, 0, 0, 0, width, height);
if (pixbuf)
ret = gdk_pixbuf_save(pixbuf, name, "png", &err, NULL);
if (!pixbuf || !ret)
printf("error creating %s\n", name);
break;
default:
printf("ret : %i\n", ret);
}
free(name);
}
int main(int argc, char *argv[])
{
gnome_init(VERSION, VERSION, argc, argv);
/* Set up to draw from card class */
GtkWidget *vbox, *vbox1, *vbox2, *vbox3;
GtkWidget *tbar;
GtkWidget *setbutton, *nosetbutton;
GdkColor white, black, blue;
/* Done setting up */
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Set Game");
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, TRUE);
gtk_container_border_width(GTK_CONTAINER(window), 0);
vbox= gtk_vbox_new(FALSE, 0);
vbox1 = gtk_vbox_new(FALSE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
vbox3 = gtk_vbox_new(FALSE, 0);
drawing_area = gtk_drawing_area_new();
gtk_widget_set_events(drawing_area,
GDK_EXPOSURE_MASK|GDK_BUTTON_PRESS_MASK);
gtk_widget_set_events(window, GDK_KEY_PRESS_MASK);
gtk_signal_connect(GTK_OBJECT(drawing_area), "expose_event",
GTK_SIGNAL_FUNC(expose_event), 0);
gtk_signal_connect(GTK_OBJECT(drawing_area), "button_press_event",
GTK_SIGNAL_FUNC(button_event), 0);
GnomeUIInfo toolbar[ ] = {
GNOMEUIINFO_ITEM_STOCK ("New Game", "Start new Game", newgame, GNOME_STOCK_PIXMAP_NEW),
GNOMEUIINFO_ITEM_STOCK ("High Scores", "Shows High scores", gtk_main_quit, GNOME_STOCK_PIXMAP_SCORES),
GNOMEUIINFO_ITEM_STOCK ("End Game", "Ends Current Game", gtk_main_quit, GNOME_STOCK_PIXMAP_STOP),
GNOMEUIINFO_ITEM_STOCK ("Exit", "Exit the application", gtk_main_quit, GNOME_STOCK_PIXMAP_EXIT),
GNOMEUIINFO_END
};
tbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
gnome_app_fill_toolbar(GTK_TOOLBAR(tbar), toolbar, gtk_accel_group_new());
gtk_box_pack_start(GTK_BOX(vbox1), tbar, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vbox3, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), drawing_area, TRUE, TRUE, 5);
gtk_drawing_area_size(GTK_DRAWING_AREA(drawing_area), SPACE_INTER+CARD_WS*4, SPACE_INTER+CARD_HS*3);
gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Player"), TRUE, TRUE, 1);
playerscore = gtk_label_new("0");
gtk_box_pack_start(GTK_BOX(vbox3), playerscore, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Computer"), TRUE, TRUE, 1);
computerscore = gtk_label_new("0");
gtk_box_pack_start(GTK_BOX(vbox3), computerscore, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(vbox3), gtk_label_new("Cards Remaining"), TRUE, TRUE, 1);
cards_remain = gtk_label_new("81");
gtk_box_pack_start(GTK_BOX(vbox3), cards_remain, TRUE, TRUE, 1);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show_all(window);
gtk_idle_add( myidle, NULL);
/************************ Start Deck Setup *************************/
unsigned char *pixmap_data[] = {
bean_e_bits,
bean_s_bits,
bean_f_bits,
blob_e_bits,
blob_s_bits,
blob_f_bits,
diamond_e_bits,
diamond_s_bits,
diamond_f_bits
};
int i, j;
GdkWindow *wn = window->window;
GdkColor col[4];
GdkColormap *cmap = gdk_window_get_colormap(wn);
GdkGC *gc;
GtkStyle *style = gtk_widget_get_style(window);
col[0].red = 54000; col[0].green = col[0].blue = 0;
col[1].green = 40000; col[1].red = col[1].blue = 0;
col[2].red = col[2].blue = 32000; col[2].green = 0;
gdk_color_white(cmap, &white);
gdk_color_black(cmap, &black);
blue.red = blue.green = 0; blue.blue = 48000;
gdk_color_alloc(cmap, &blue);
for (i=0; i<3; i++)
gdk_color_alloc(cmap, &col[i]);
for (i=0; i<9; i++)
for (j=0; j<3; j++)
card_pixmap[i*3+j] = gdk_pixmap_create_from_data(wn, (gchar*) pixmap_data[i],
SHAPE_W, SHAPE_H, -1, &col[j], &white);
/* free colors? !! */
gc = gdk_gc_new(wn);
/*** cards in normal state ***/
card_bkg = gdk_pixmap_new(wn, CARD_WIDTH, CARD_HEIGHT, -1);
/* clear the card */
gdk_gc_set_foreground(gc, &style->bg[GTK_STATE_NORMAL]);
gdk_draw_rectangle(card_bkg, gc, 1, 0, 0, CARD_WIDTH, CARD_HEIGHT);
/* draw corner arcs */
gdk_gc_set_foreground(gc, &white);
gdk_draw_arc(card_bkg, gc, 1, 0, 0,
2*ARC_SIZE, 2*ARC_SIZE, 90*64, 90*64);
gdk_draw_arc(card_bkg, gc, 1, CARD_WIDTH-2*ARC_SIZE, 0,
2*ARC_SIZE, 2*ARC_SIZE, 0, 90*64);
gdk_draw_arc(card_bkg, gc, 1, 0, CARD_HEIGHT-2*ARC_SIZE,
2*ARC_SIZE, 2*ARC_SIZE, 180*64, 90*64);
gdk_draw_arc(card_bkg, gc, 1, CARD_WIDTH-2*ARC_SIZE,
CARD_HEIGHT-2*ARC_SIZE, 2*ARC_SIZE, 2*ARC_SIZE, 270*64, 90*64);
/* draw the rest */
gdk_draw_rectangle(card_bkg, gc, 1, ARC_SIZE, 0, CARD_WIDTH-2*ARC_SIZE, CARD_HEIGHT);
gdk_draw_rectangle(card_bkg, gc, 1, 0, ARC_SIZE, CARD_WIDTH, CARD_HEIGHT-2*ARC_SIZE);
gdk_gc_destroy(gc);
/************************ End Deck Setup *************************/
/* done setting up for once
to draw
wn = drawing_area->window;
gc-gdk_gc_new(wn);
card1.draw();
.............draw();
gdk_gc_destroy();
Card(int colr, int shp, int num, int shdng);
*/
mytable.Draw();
gtk_main();
return 0;
}
