void free_pixmaps (void)
{
unsigned i;
free_pixmap (&update_pix);
free_pixmap (&refresh_pix);
free_pixmap (&refrsel_pix);
free_pixmap (&stop_pix);
free_pixmap (&connect_pix);
free_pixmap (&observe_pix);
free_pixmap (&record_pix);
free_pixmap (&sfilter_pix);
free_pixmap (&sfilter_cfg_pix);
free_pixmap (&pfilter_pix);
free_pixmap (&pfilter_cfg_pix);
free_pixmap (&gplus_pix);
free_pixmap (&rminus_pix);
free_pixmap (&man_black_pix);
free_pixmap (&man_red_pix);
free_pixmap (&man_yellow_pix); // He's actually green
for (i = 0; i < 3; i++)
free_pixmap (&group_pix[i]);
for (i = 0; i < 9; i++)
free_pixmap (&buddy_pix[i]);
free_pixmap (&error_pix);
free_pixmap (&delete_pix);
for (i = 0; i < 5; i++)
free_pixmap (&server_status[i]);
free_pixmap (&locked_pix);
free_pixmap (&punkbuster_pix);
free_pixmap (&locked_punkbuster_pix);
for (i = 0; i < GAMES_TOTAL; i++)
{
free_pixmap(games[i].pix);
g_free(games[i].pix);
games[i].pix = NULL;
}
if (pixmaps_gc) {
gdk_gc_destroy (pixmaps_gc);
pixmaps_gc = NULL;
}
if (masks_gc) {
gdk_gc_destroy (masks_gc);
masks_gc = NULL;
}
}
GdkBitmap *
arc_clip_mask(gint width,
gint height)
{
GdkBitmap *result;
GdkGC *gc;
GdkColor color;
result = (GdkBitmap *)gdk_pixmap_new(NULL, width, height, 1);
gc = gdk_gc_new(result);
color.pixel = 0;
gdk_gc_set_foreground(gc, &color);
gdk_draw_rectangle(result, gc, TRUE, 0, 0, width, height);
gdk_draw_rectangle(result, gc, FALSE, 0, 0, width, height);
color.pixel = 1;
gdk_gc_set_foreground(gc, &color);
gdk_draw_arc(result, gc, TRUE, 0, 0, width, height, 0, 360*64);
gdk_draw_arc(result, gc, FALSE, 0, 0, width, height, 0, 360*64);
gdk_gc_destroy(gc);
return result;
}
void SystemDraw::DrawRectOp(int x, int y, int cx, int cy, Color color)
{
if(IsNull(color))
return;
FlushText();
cairo_rectangle(cr, x, y, cx, cy);
if(color == InvertColor()) {
#if GTK_CHECK_VERSION(2,24,0) && (CAIRO_VERSION_MAJOR > 1 || CAIRO_VERSION_MINOR > 9)
SetColor(White());
cairo_set_operator(cr, CAIRO_OPERATOR_DIFFERENCE);
cairo_fill(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
#else
if(drawable) {
GdkGC *gc = gdk_gc_new(drawable);
gdk_gc_set_function(gc, GDK_INVERT);
Point o = GetOffset();
gdk_draw_drawable(drawable, gc, drawable, x + o.x, y + o.y, x + o.x, y + o.y, cx, cy);
gdk_gc_set_function(gc, GDK_COPY);
gdk_gc_destroy(gc);
}
#endif
}
else {
SetColor(color);
cairo_fill(cr);
}
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkGraphics_dispose
(JNIEnv *env, jobject obj)
{
struct graphics *g;
g = (struct graphics *) NSA_DEL_PTR (env, obj);
if (!g) return; /* dispose has been called more than once */
gdk_threads_enter ();
XFlush (GDK_DISPLAY ());
gdk_gc_destroy (g->gc);
if (GDK_STABLE_IS_PIXMAP (g->drawable))
gdk_pixmap_unref (g->drawable);
else /* GDK_IS_WINDOW (g->drawable) */
gdk_window_unref (g->drawable);
gdk_colormap_unref (g->cm);
gdk_threads_leave ();
free (g);
}
void gpk_rectangle_draw(GtkWidget *widget, /* plot on this widged */
gdouble *xcord, gdouble *ycord, /* corners */
gdouble xmn,gdouble ymn, /* coordinates of corners */
gdouble xmx,gdouble ymx,
GdkColor *color)
{
GdkPixmap **ppixmap;
GdkPoint points[2];
int i;
gint16 width,height;
GdkGC *gc;
gc = gdk_gc_new(widget->window);
gdk_gc_set_foreground(gc, color);
if ((ppixmap=findpixmap(widget))) {
width = widget->allocation.width;
height = widget->allocation.height;
for (i=0; i<2 ; i++) {
points[i].x =.5+ ((xcord[i]-xmn)*(width-1)/(xmx-xmn));
points[i].y =.5+ ((ycord[i]-ymx)*(height-1)/(ymn-ymx));
}
width=points[1].x-points[0].x + 1;
height=points[1].y-points[0].y + 1;
gdk_draw_rectangle(*ppixmap,gc,TRUE,
points[0].x,points[0].y,width,height);
gpk_redraw(*ppixmap,widget);
}
gdk_gc_destroy(gc);
}
gint
wgra_configure(GtkWidget *widget,GdkEventConfigure *ee,gpointer data)
{
GdkGC *mygc;
int x,y,cx,xs;
int i,v;
long max;
float fac;
GdkFont *fn;
if (wcanvas!=NULL)
gdk_pixmap_unref(wcanvas);
mygc=gdk_gc_new(widget->window);
wcanvas=gdk_pixmap_new(widget->window,x=widget->allocation.width,
y=widget->allocation.height,-1);
gdk_draw_rectangle(wcanvas,widget->style->white_gc,TRUE,0,0,x,y);
gdk_draw_rectangle(wcanvas,widget->style->black_gc,FALSE,0,0,x-1,y-1);
max=0;
for(i=0;i<7;i++)
if (weekly[i]>max)
max=weekly[i];
if (!max) max=1;
fac=((float)(y-18-16))/((float)max);
cx=1;
xs=(x-2)/7;
fn=gdk_font_load("-*-helvetica-medium-r-*-*-8-*-*-*-*-*-*-*");
for (i=0;i<7;i++) {
v=(int)(((float)weekly[i])*fac);
gdk_rgb_gc_set_foreground(mygc,0xc0c0c0);
gdk_draw_line(wcanvas,mygc,cx,1,cx,y-2);
gdk_rgb_gc_set_foreground(mygc,0x004080);
gdk_draw_rectangle(wcanvas,mygc,TRUE,cx,y-18-v,xs,v);
gdk_rgb_gc_set_foreground(mygc,0x000000);
gdk_draw_string(wcanvas,fn,mygc,cx,y-6,wdays[i]);
cx+=xs;
}
gdk_draw_line(wcanvas,widget->style->black_gc,0,y-18,x-1,y-18);
gdk_rgb_gc_set_foreground(mygc,0xffffff);
gdk_draw_rectangle(wcanvas,mygc,TRUE,0,0,23*4,13);
gdk_rgb_gc_set_foreground(mygc,0x000000);
gdk_draw_rectangle(wcanvas,mygc,FALSE,0,0,23*4,13);
gdk_font_unref(fn);
fn=gdk_font_load("-*-helvetica-medium-r-*-*-10-*-*-*-*-*-*-*");
gdk_draw_string(wcanvas,fn,mygc,5,10,"weekday summary");
gdk_font_unref(fn);
gdk_gc_destroy(mygc);
return FALSE;
}
/* update_window:
* Copy the backing image onto the window. */
void update_window() {
if (backing_image) {
GdkGC *gc;
gc = gdk_gc_new(drawable);
gdk_draw_rgb_32_image(drawable, gc, 0, 0, width, height, GDK_RGB_DITHER_NORMAL, (guchar*)backing_image->flat, sizeof(pel) * width);
gdk_gc_destroy(gc);
}
}
static void
gtk_plot_gdk_finalize (GtkObject *object)
{
gdk_window_unref(GTK_PLOT_GDK(object)->window);
if(GTK_PLOT_GDK(object)->ref_count > 0 && GTK_PLOT_GDK(object)->gc)
gdk_gc_destroy(GTK_PLOT_GDK(object)->gc);
}
void gpk_graph_draw(GtkWidget *widget, /* plot on this widged */
int n, /* number of data points */
gdouble *xcord, gdouble *ycord, /* data */
gdouble xmn,gdouble ymn, /* coordinates of corners */
gdouble xmx,gdouble ymx,
int clear, /* clear old plot first */
char *title, /* add a title (only if clear=1) */
GdkColor *color)
{
GdkPixmap **ppixmap;
GdkPoint *points;
int i;
gint16 width,height;
GdkFont *fixed_font;
GdkGC *gc;
gc = gdk_gc_new(widget->window);
gdk_gc_set_foreground(gc, color);
if ((ppixmap=findpixmap(widget))) {
width = widget->allocation.width;
height = widget->allocation.height;
if (clear) {
/* white background */
gdk_draw_rectangle (*ppixmap,
widget->style->white_gc,
TRUE,0, 0,width,height);
/* title */
#ifdef _WIN32
fixed_font = gdk_font_load ("-misc-fixed-large-r-*-*-*-100-*-*-*-*-*-*");
#else
fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-100-*-*-*-*-iso8859-1");
#endif
gdk_draw_text (*ppixmap,fixed_font,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
0,10,title,strlen(title));
}
points = g_malloc(n*sizeof(GdkPoint));
for (i=0; i<n ; i++) {
points[i].x =.5+ ((xcord[i]-xmn)*(width-1)/(xmx-xmn));
points[i].y =.5+ ((ycord[i]-ymx)*(height-1)/(ymn-ymx));
}
gdk_draw_lines(*ppixmap,gc,points,n);
g_free(points);
gpk_redraw(*ppixmap,widget);
}
gdk_gc_destroy(gc);
}
static gboolean
ui_update(Bubblemon *base)
{
int w, h, i;
const bubblemon_picture_t *bubblePic;
bubblemon_color_t *pixel;
guchar *p;
GdkGC *gc;
GtkWidget *draw_area = base->draw_area;
if((draw_area == NULL) ||
!GTK_WIDGET_REALIZED(draw_area) ||
!GTK_WIDGET_DRAWABLE(draw_area) ||
base->width <= 0)
{
return TRUE;
}
bubblePic = bubblemon_getPicture(base->bubblemon);
if ((bubblePic == NULL) ||
(bubblePic->width == 0) ||
(bubblePic->pixels == 0))
{
return TRUE;
}
w = bubblePic->width;
h = bubblePic->height;
gc = gdk_gc_new(draw_area->window);
p = base->rgb_buffer;
pixel = bubblePic->pixels;
for(i = 0; i < w * h; i++) {
*(p++) = pixel->components.r;
*(p++) = pixel->components.g;
*(p++) = pixel->components.b;
pixel++;
}
gdk_draw_rgb_image(draw_area->window, gc,
0, 0,
base->width, base->height,
GDK_RGB_DITHER_NORMAL,
base->rgb_buffer, w * 3);
gdk_gc_destroy(gc);
return TRUE;
}
static void
embeddable_clear_image (embeddable_data_t *embeddable_data)
{
GdkGC *temp_gc;
temp_gc = gdk_gc_new (embeddable_data->pixmap);
gdk_draw_rectangle (embeddable_data->pixmap,
temp_gc,
TRUE, 0, 0,
embeddable_data->width,
embeddable_data->height);
gdk_gc_destroy (temp_gc);
}
static gboolean touchscreen_callback(GtkWidget *widget, GdkEventMotion *event)
{
GdkGC *gc;
PangoLayout *layout;
char buf[64];
sprintf(buf, "<span size=\"30000\">[%d, %d]</span>",
(int)event->x, (int)event->y);
gdk_window_clear(widget->window);
gc = gdk_gc_new(widget->window);
layout = gtk_widget_create_pango_layout(widget, "");
pango_layout_set_markup(layout, buf, -1);
gdk_draw_layout(widget->window, gc, 80, 80, layout);
g_object_unref(layout);
gdk_gc_destroy(gc);
return TRUE;
}
static void
gtk_hex_entry_unrealize (GtkWidget *widget)
{
GtkHexEntry *hex_entry;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HEX_ENTRY (widget));
hex_entry = GTK_HEX_ENTRY (widget);
gdk_gc_destroy (hex_entry->gc);
hex_entry->gc = NULL;
gdk_cursor_destroy (hex_entry->cursor);
hex_entry->cursor = NULL;
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
static void
gtk_plot_gdk_finalize (GObject *object)
{
GtkPlotGdk *pc = GTK_PLOT_GDK(object);
GTK_PLOT_GDK(object)->window = NULL;
if(GTK_PLOT_GDK(object)->ref_count > 0 && GTK_PLOT_GDK(object)->gc){
gdk_gc_destroy(GTK_PLOT_GDK(object)->gc);
GTK_PLOT_GDK(object)->gc = NULL;
}
if(pc->layout)
g_object_unref(G_OBJECT(pc->layout));
pc->layout = NULL;
if(pc->context)
g_object_unref(G_OBJECT(pc->context));
pc->context = NULL;
}
static int about_dialog_load_logo(GtkWidget * window)
{
GtkWidget *preview;
GdkGC *gc;
char buf[1024];
char *c;
unsigned char *pixelrow;
FILE *fp;
int count;
int i;
if (logo_pixmap)
return TRUE;
snprintf(buf, sizeof(buf), "%s/aube_logo.ppm", DATADIR);
fp = fopen(buf, "rb");
if (!fp)
return FALSE;
c = fgets(buf, 1024, fp);
if (!c || strcmp(buf, "P6\n") != 0)
goto out_err;
if (!fgets(buf, 1024, fp))
goto out_err;
if (!fgets(buf, 1024, fp))
goto out_err;
sscanf(buf, "%d %d", &logo_width, &logo_height);
if (!fgets(buf, 1024, fp))
goto out_err;
if (strcmp(buf, "255\n") != 0)
goto out_err;
preview = gtk_preview_new(GTK_PREVIEW_COLOR);
gtk_preview_size(GTK_PREVIEW(preview), logo_width, logo_height);
pixelrow = g_new(guchar, logo_width * 3);
for (i = 0; i < logo_height; i++) {
count =
fread(pixelrow, sizeof(unsigned char), logo_width * 3,
fp);
if (count != (logo_width * 3)) {
gtk_widget_destroy(preview);
g_free(pixelrow);
goto out_err;
}
gtk_preview_draw_row(GTK_PREVIEW(preview), pixelrow, 0, i,
logo_width);
}
gtk_widget_realize(window);
logo_pixmap =
gdk_pixmap_new(window->window, logo_width, logo_height,
gtk_preview_get_visual()->depth);
gc = gdk_gc_new(logo_pixmap);
gtk_preview_put(GTK_PREVIEW(preview),
logo_pixmap, gc,
0, 0, 0, 0, logo_width, logo_height);
gdk_gc_destroy(gc);
gtk_widget_unref(preview);
g_free(pixelrow);
fclose(fp);
return TRUE;
out_err:
fclose(fp);
return FALSE;
}
void
gpk_bargraph_draw(GtkWidget * widget, /* plot on this widged */
int n, /* number of data points */
gdouble * xcord, gdouble * ycord, /* data */
gdouble xmn, gdouble ymn, /* coordinates of corners */
gdouble xmx, gdouble ymx, int clear, /* clear old plot first */
char *title, /* add a title (only if clear=1) */
int barwidth, /* bar width. 0=compute based on window size */
GdkColor * color)
{
GdkPixmap **ppixmap;
GdkPoint points[2];
int i;
gint16 width, height, x, y, barheight;
GdkFont *fixed_font;
GdkGC *gc;
int titleSplit;
gc = gdk_gc_new(widget->window);
gdk_gc_set_foreground(gc, color);
if ((ppixmap = findpixmap(widget))) {
width = widget->allocation.width;
height = widget->allocation.height;
if (clear) {
/* white background */
gdk_draw_rectangle(*ppixmap, widget->style->white_gc, TRUE, 0, 0, width, height);
/* title */
#ifdef _WIN32
fixed_font = gdk_font_load("-misc-fixed-large-r-*-*-*-100-*-*-*-*-*-*");
#else
fixed_font = gdk_font_load("-misc-fixed-medium-r-*-*-*-100-*-*-*-*-iso8859-1");
#endif
titleSplit = strcspn(title, "\n");
if (titleSplit && (titleSplit != strlen(title))) {
gdk_draw_text(*ppixmap, fixed_font,
widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
0, 10, title, titleSplit);
gdk_draw_text(*ppixmap, fixed_font,
widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
0, 22, title + titleSplit + 1, (strlen(title) - titleSplit) - 1);
}
else {
gdk_draw_text(*ppixmap, fixed_font,
widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
0, 10, title, strlen(title));
}
}
for (i = 0; i < n; i++) {
points[1].x = .5 + ((xcord[i] - xmn) * (width - 1) / (xmx - xmn));
points[1].y = .5 + ((ycord[i] - ymx) * (height - 1) / (ymn - ymx));
points[0].x = points[1].x;
points[0].y = height - 1;
x = .5 + ((xcord[i] - xmn) * (width - 1) / (xmx - xmn));
y = .5 + ((ycord[i] - ymx) * (height - 1) / (ymn - ymx));
if (!barwidth)
barwidth = (width / (n + 1)) - 1;
barwidth = barwidth > 5 ? 5 : barwidth;
barwidth = barwidth < 1 ? 1 : barwidth;
barheight = height - 1 - y;
/* gdk_draw_lines(*ppixmap,gc,points,2); */
gdk_draw_rectangle(*ppixmap, gc, TRUE, x, y, barwidth, barheight);
}
gpk_redraw(*ppixmap, widget);
}
gdk_gc_destroy(gc);
}
//! initialization of the board
void board_init ()
{
int i;
GdkColormap *board_colormap;
Game *game = opt_game;
GdkGC *def_gc = gdk_gc_new ((GdkWindow *)board_area->window);
// GtkWidget *hbox, *vbox;
state_board_flipped = FALSE;
if (!game)
{
#if GTK_MAJOR_VERSION == 1
gtk_drawing_area_size (GTK_DRAWING_AREA (board_area), 300, 300);
#else
gtk_widget_set_size_request (GTK_WIDGET (board_area), 300, 300);
#endif
return;
}
#if GTK_MAJOR_VERSION == 1
gtk_drawing_area_size (GTK_DRAWING_AREA (board_area),
cell_size * board_wid, cell_size * board_heit);
#else
gtk_widget_set_size_request (GTK_WIDGET (board_area),
cell_size * board_wid, cell_size * board_heit);
#endif
pieces = (GdkPixmap **) malloc (2 * num_pieces * sizeof (GdkPixmap *));
g_assert (pieces);
piece_masks = (GdkBitmap **) malloc (2 * num_pieces * sizeof (GdkBitmap *));
g_assert (piece_masks);
for (i=0; i<2*num_pieces; i++)
pieces[i] = NULL;
if (game_file_label)
{
board_rowbox_real = gtk_hbox_new (TRUE, 0);
gtk_box_pack_end (GTK_BOX (board_rowbox), board_rowbox_real, FALSE, FALSE, 0);
#if GTK_MAJOR_VERSION == 1
gtk_widget_set_usize (GTK_WIDGET (board_rowbox_real),
cell_size * board_wid, -1);
#else
gtk_widget_set_size_request
(GTK_WIDGET (board_rowbox_real), cell_size * board_wid, -1);
#endif
for (i=0; i<board_wid; i++)
gtk_container_add (GTK_CONTAINER (board_rowbox_real),
gtk_label_new (board_get_file_label_str (game_file_label, i)));
gtk_widget_show_all (board_rowbox);
}
if (game_rank_label)
{
board_colbox_real = gtk_vbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (board_colbox), board_colbox_real, FALSE, FALSE, 0);
#if GTK_MAJOR_VERSION == 1
gtk_widget_set_usize (GTK_WIDGET (board_colbox_real),
-1, cell_size * board_heit);
#else
gtk_widget_set_size_request
(GTK_WIDGET (board_colbox_real), -1, cell_size * board_heit);
#endif
for (i=0; i<board_heit; i++)
gtk_container_add (GTK_CONTAINER (board_colbox_real),
gtk_label_new (board_get_rank_label_str
(game_rank_label, i)));
gtk_widget_show_all (board_colbox);
}
if (game->colors == NULL) game->colors = board_default_colors;
board_colormap = gdk_colormap_get_system ();
board_color_init (&game->colors[0],
&board_colors[0], &board_gcs[0], board_colormap, board_area);
board_color_init (&game->colors[3],
&board_colors[1], &board_gcs[1], board_colormap, board_area);
if (game_draw_cell_boundaries)
board_color_init (&game->colors[6],
&board_colors[2], &board_gcs[2], board_colormap, board_area);
if (game_highlight_colors)
for (i=0; i<3; i++)
board_color_init (&game_highlight_colors[3*i],
&board_highlight_colors[i], &board_highlight_gcs[i],
board_colormap, board_area);
{
char buttonize_colors [6] = {240, 240, 240, 128, 128, 128};
for (i=0; i<2; i++)
board_color_init (&buttonize_colors[3*i], &board_buttonize_colors[i],
&board_buttonize_gcs[i], board_colormap, board_area);
}
g_assert (num_pieces);
for (i=0; i<2*num_pieces; i++)
{
char **pixmap = NULL;
guchar *rgbbuf = NULL;
{
byte *colors = game->colors;
if (i >= num_pieces && colors[0] == colors[3] && colors[1] == colors[4]
&& colors[2] == colors[5])
{
pieces[i] = pieces[i-num_pieces];
piece_masks[i] = piece_masks[i-num_pieces];
continue;
}
}
if (game_get_rgbmap)
{
rgbbuf = game_get_rgbmap(1+i%num_pieces, i < num_pieces ? WHITE: BLACK);
if (rgbbuf)
{
pieces[i] = gdk_pixmap_new (
board_area->window, cell_size, cell_size, -1);
gdk_draw_rgb_image ((GdkDrawable *)pieces[i],
def_gc, 0, 0,
cell_size, cell_size, GDK_RGB_DITHER_MAX,
rgbbuf, cell_size * 3);
}
piece_masks[i] = NULL;
}
else
{
if (game_get_pixmap)
pixmap = game_get_pixmap
(1+i%num_pieces, i < num_pieces ? WHITE: BLACK);
else
pixmap = game->pixmaps [i%num_pieces];
if (pixmap)
{
pieces[i] = gdk_pixmap_colormap_create_from_xpm_d (NULL,
board_colormap, &piece_masks[i],
board_colors + i / num_pieces, pixmap);
assert (pieces[i]);
}
else piece_masks[i] = NULL;
}
}
if (game_bg_pixmap)
{
board_bgimage = gdk_pixmap_colormap_create_from_xpm_d (NULL,
board_colormap, NULL, board_colors, game_bg_pixmap);
assert (board_bgimage);
}
gdk_gc_destroy (def_gc);
}
static void *font_gtk_get_glyph(unsigned char *str) {
agsurface_t *dst;
int h, w, l;
BYTE *conv;
GdkPixmap *pix_gdk;
GdkGC *gc_gdk;
GdkImage *img_gdk;
GdkColor col_gdk;
/* convert string code from sjis to euc (or LANG) */
conv = sjis2lang(str);
l = strlen(conv);
w = gdk_text_width(fontset, conv, l);
if (w == 0) {
free(conv);
return NULL;
}
#ifdef GTKV12
h = gdk_text_height(fontset, conv, l);
#else
h = font_ascent + fontset->ascent;
#endif
if (w > GLYPH_PIXMAP_WIDTH) w = GLYPH_PIXMAP_WIDTH;
if (h > GLYPH_PIXMAP_HEIGHT) h = GLYPH_PIXMAP_HEIGHT;
pix_gdk = gdk_pixmap_new(mainwin->window, w, h, gdk_depth);
gc_gdk = gdk_gc_new(pix_gdk);
/* color */
col_gdk.pixel = 0;
gdk_gc_set_foreground(gc_gdk, &col_gdk);
// gdk_gc_set_background(gc_gdk, &col_gdk);
gdk_draw_rectangle(pix_gdk, gc_gdk, TRUE, 0, 0, w, h);
col_gdk.pixel = 1;
gdk_gc_set_foreground(gc_gdk, &col_gdk);
gdk_draw_text(pix_gdk, fontset, gc_gdk, 0, fontset->ascent, conv, l);
gdk_gc_destroy(gc_gdk);
img_gdk = gdk_image_get(&((GdkWindowPrivate *)pix_gdk)->window,
0, 0, w, h);
gdk_pixmap_unref(pix_gdk);
dst = g_new(agsurface_t, 1);
dst->width = w;
dst->height = h;
dst->bytes_per_pixel = (img_gdk->bpp+1)/8; /* むーん */
dst->bytes_per_line = img_gdk->bpl;
dst->pixel = img_gdk->mem;
image_get_glyph(dst, &img_glyph);
if (this->antialiase_on) {
aa_make(img_glyph.pixel, w, dst->height, img_glyph.bytes_per_line);
}
img_glyph.width = w;
img_glyph.height = h;
g_free(dst);
g_free(conv);
gdk_image_destroy(img_gdk);
return &img_glyph;
}
/*
* This callback is envoked when the view is destroyed. We use it to
* free up our ancillary view-centric data structures.
*/
static void
view_destroy_cb (BonoboView *view, view_data_t *view_data)
{
gdk_gc_destroy (view_data->gc);
g_free (view_data);
}
static PyObject *Py_agg_to_gtk_drawable(PyObject *self, PyObject *args, PyObject *kwds)
{
typedef agg::pixfmt_rgba32_plain pixfmt;
typedef agg::renderer_base<pixfmt> renderer_base;
PyGObject *py_drawable;
numpy::array_view<agg::int8u, 3> buffer;
agg::rect_d rect;
// args are gc, renderer, bbox where bbox is a transforms BBox
// (possibly None). If bbox is None, blit the entire agg buffer
// to gtk. If bbox is not None, blit only the region defined by
// the bbox
if (!PyArg_ParseTuple(args,
"OO&O&:agg_to_gtk_drawable",
&py_drawable,
&buffer.converter,
&buffer,
&convert_rect,
&rect)) {
return NULL;
}
if (buffer.dim(2) != 4) {
PyErr_SetString(PyExc_ValueError, "Invalid image buffer. Must be NxMx4.");
return NULL;
}
GdkDrawable *drawable = GDK_DRAWABLE(py_drawable->obj);
GdkGC *gc = gdk_gc_new(drawable);
int srcstride = buffer.dim(1) * 4;
int srcwidth = buffer.dim(1);
int srcheight = buffer.dim(0);
// these three will be overridden below
int destx = 0;
int desty = 0;
int destwidth = 1;
int destheight = 1;
int deststride = 1;
std::vector<agg::int8u> destbuffer;
agg::int8u *destbufferptr;
if (rect.x1 == 0.0 && rect.x2 == 0.0 && rect.y1 == 0.0 && rect.y2 == 0.0) {
// bbox is None; copy the entire image
destbufferptr = (agg::int8u *)buffer.data();
destwidth = srcwidth;
destheight = srcheight;
deststride = srcstride;
} else {
destx = (int)rect.x1;
desty = srcheight - (int)rect.y2;
destwidth = (int)(rect.x2 - rect.x1);
destheight = (int)(rect.y2 - rect.y1);
deststride = destwidth * 4;
destbuffer.reserve(destheight * deststride);
destbufferptr = &destbuffer[0];
agg::rendering_buffer destrbuf;
destrbuf.attach(destbufferptr, destwidth, destheight, deststride);
pixfmt destpf(destrbuf);
renderer_base destrb(destpf);
agg::rendering_buffer srcrbuf;
srcrbuf.attach((agg::int8u *)buffer.data(), buffer.dim(1), buffer.dim(0), buffer.dim(1) * 4);
agg::rect_base<int> region(destx, desty, (int)rect.x2, srcheight - (int)rect.y1);
destrb.copy_from(srcrbuf, ®ion, -destx, -desty);
}
gdk_draw_rgb_32_image(drawable,
gc,
destx,
desty,
destwidth,
destheight,
GDK_RGB_DITHER_NORMAL,
destbufferptr,
deststride);
gdk_gc_destroy(gc);
Py_RETURN_NONE;
}
static void
gtk_gc_destroy (gpointer value)
{
gdk_gc_destroy ((GdkGC*) value);
}
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;
}
