static void
gtk_plot_bar_init (GtkPlotBar *dataset)
{
GtkWidget *widget;
GdkColor black, white;
GdkColormap *colormap;
GtkPlotArray *dim;
widget = GTK_WIDGET(dataset);
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
GTK_PLOT_DATA(dataset)->symbol.symbol_style = GTK_PLOT_SYMBOL_FILLED;
GTK_PLOT_DATA(dataset)->symbol.color = white;
GTK_PLOT_DATA(dataset)->line.line_style = GTK_PLOT_LINE_SOLID;
GTK_PLOT_DATA(dataset)->line.line_width = 1;
GTK_PLOT_DATA(dataset)->line.color = black;
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "y");
gtk_plot_array_set_label(dim, "Size");
gtk_plot_array_set_description(dim, "Bar size");
dataset->width = .05;
}
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;
}
gboolean
ghid_port_drawing_area_configure_event_cb (GtkWidget * widget,
GdkEventConfigure * ev,
GHidPort * out)
{
static gboolean first_time_done;
HideCrosshair (TRUE);
gport->width = ev->width;
gport->height = ev->height;
if (gport->pixmap)
gdk_pixmap_unref (gport->pixmap);
gport->pixmap = gdk_pixmap_new (widget->window,
gport->width, gport->height, -1);
gport->drawable = gport->pixmap;
if (!first_time_done)
{
gport->colormap = gtk_widget_get_colormap (gport->top_window);
gport->bg_gc = gdk_gc_new (gport->drawable);
if (gdk_color_parse (Settings.BackgroundColor, &gport->bg_color))
gdk_color_alloc (gport->colormap, &gport->bg_color);
else
gdk_color_white (gport->colormap, &gport->bg_color);
gdk_gc_set_foreground (gport->bg_gc, &gport->bg_color);
gport->offlimits_gc = gdk_gc_new (gport->drawable);
if (gdk_color_parse (Settings.OffLimitColor, &gport->offlimits_color))
gdk_color_alloc (gport->colormap, &gport->offlimits_color);
else
gdk_color_white (gport->colormap, &gport->offlimits_color);
gdk_gc_set_foreground (gport->offlimits_gc, &gport->offlimits_color);
first_time_done = TRUE;
PCBChanged (0, NULL, 0, 0);
}
if (gport->mask)
{
gdk_pixmap_unref (gport->mask);
gport->mask = gdk_pixmap_new (0, gport->width, gport->height, 1);
}
ghid_port_ranges_scale (FALSE);
ghid_invalidate_all ();
RestoreCrosshair (TRUE);
return 0;
}
static void
gtk_plot_flux_init (GtkPlotFlux *dataset)
{
GtkWidget *widget;
GdkColor black, white;
GdkColormap *colormap;
GtkPlotArray *dim;
widget = GTK_WIDGET(dataset);
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
GTK_PLOT_DATA(dataset)->symbol.symbol_style = GTK_PLOT_SYMBOL_EMPTY;
GTK_PLOT_DATA(dataset)->symbol.color = black;
GTK_PLOT_DATA(dataset)->line.line_style = GTK_PLOT_LINE_SOLID;
GTK_PLOT_DATA(dataset)->line.line_width = 1;
GTK_PLOT_DATA(dataset)->line.color = black;
dataset->centered = TRUE;
dataset->arrow_length = 8;
dataset->arrow_width = 8;
dataset->arrow_style = GTK_PLOT_SYMBOL_FILLED;
dataset->size_max = 1;
dataset->scale_max = 1.;
dataset->show_scale = TRUE;
dataset->labels_precision = 3;
dataset->labels_style = GTK_PLOT_LABEL_FLOAT;
dataset->labels_prefix = NULL;
dataset->labels_suffix = NULL;
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "x");
gtk_plot_array_set_description(dim, "Position X");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "y");
gtk_plot_array_set_description(dim, "Position Y");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_independent(dim, TRUE);
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "z");
gtk_plot_array_set_description(dim, "Position Z");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_independent(dim, TRUE);
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "dx");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "DX");
gtk_plot_array_set_description(dim, "Size X");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "dy");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "DY");
gtk_plot_array_set_description(dim, "Size Y");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "dz");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "DZ");
gtk_plot_array_set_description(dim, "Size Z");
}
void UI_buildui(IBusHandwriteEngine * engine)
{
GdkPixmap * pxmp;
GdkGC * gc;
GdkColor black, white;
GdkColormap* colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
g_object_unref(colormap);
int R = 5;
if (!engine->drawpanel)
//建立绘图窗口, 建立空点
{
engine->drawpanel = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_move((GtkWindow*) engine->drawpanel, 500, 550);
gtk_widget_add_events(GTK_WIDGET(engine->drawpanel),
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK);
g_signal_connect_after(G_OBJECT(engine->drawpanel),"motion_notify_event",G_CALLBACK(on_mouse_move),engine);
g_signal_connect(G_OBJECT(engine->drawpanel),"expose-event",G_CALLBACK(paint_ui),engine);
g_signal_connect(G_OBJECT(engine->drawpanel),"button-release-event",G_CALLBACK(on_button),engine);
g_signal_connect(G_OBJECT(engine->drawpanel),"button-press-event",G_CALLBACK(on_button),engine);
gtk_window_resize(GTK_WINDOW(engine->drawpanel), 200, 250);
gtk_widget_show(engine->drawpanel);
pxmp = gdk_pixmap_new(NULL, 200, 250, 1);
gc = gdk_gc_new(GDK_DRAWABLE(pxmp));
gdk_gc_set_foreground(gc, &black);
gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, 0, 0, 200, 250);
gdk_gc_set_foreground(gc, &white);
gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 0, 0, R*2, R*2, 0, 360 * 64);
gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 200 - R*2, 0, R*2, R*2, 0, 360
* 64);
gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 200 - R*2, 250 - R*2, R*2, R*2, 0,
360 * 64);
gdk_draw_arc(GDK_DRAWABLE(pxmp), gc, 1, 0, 250 - R*2, R*2, R*2, 0, 360
* 64);
gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, 0, R, 200, 250 - R*2);
gdk_draw_rectangle(GDK_DRAWABLE(pxmp), gc, 1, R, 0, 200 - R*2, 250);
gdk_window_shape_combine_mask(engine->drawpanel->window, pxmp, 0, 0);
g_object_unref(gc);
g_object_unref(pxmp);
gtk_window_set_opacity(GTK_WINDOW(engine->drawpanel), 0.62);
// engine->GdkPoints = NULL;
}
// gtk_widget_show_all(engine->drawpanel);
}
static void
gtk_plot_canvas_ellipse_init (GtkPlotCanvasEllipse *ellipse)
{
gdk_color_black(gdk_colormap_get_system(), &ellipse->line.color);
gdk_color_white(gdk_colormap_get_system(), &ellipse->bg);
ellipse->line.line_style = GTK_PLOT_LINE_SOLID;
ellipse->line.line_width = 0;
ellipse->filled = TRUE;
}
PRIVATE int init_instance(Generator *g) {
Data *data = safe_malloc(sizeof(Data));
g->data = data;
gdk_color_white( gdk_colormap_get_system(), &(data->cube_color) );
data->cube_alpha = 0;
return TRUE;
}
gboolean
ghid_port_drawing_area_configure_event_cb (GtkWidget * widget,
GdkEventConfigure * ev,
GHidPort * out)
{
static gboolean first_time_done;
gport->width = ev->width;
gport->height = ev->height;
if (gport->pixmap)
gdk_pixmap_unref (gport->pixmap);
gport->pixmap = gdk_pixmap_new (gtk_widget_get_window (widget),
gport->width, gport->height, -1);
gport->drawable = gport->pixmap;
if (!first_time_done)
{
gport->colormap = gtk_widget_get_colormap (gport->top_window);
if (gdk_color_parse (Settings.BackgroundColor, &gport->bg_color))
gdk_color_alloc (gport->colormap, &gport->bg_color);
else
gdk_color_white (gport->colormap, &gport->bg_color);
if (gdk_color_parse (Settings.OffLimitColor, &gport->offlimits_color))
gdk_color_alloc (gport->colormap, &gport->offlimits_color);
else
gdk_color_white (gport->colormap, &gport->offlimits_color);
first_time_done = TRUE;
ghid_drawing_area_configure_hook (out);
PCBChanged (0, NULL, 0, 0);
}
else
{
ghid_drawing_area_configure_hook (out);
}
ghid_port_ranges_scale ();
ghid_invalidate_all ();
return 0;
}
static void
gtk_plot_canvas_rectangle_init (GtkPlotCanvasRectangle *rectangle)
{
gdk_color_black(gdk_colormap_get_system(), &rectangle->line.color);
gdk_color_white(gdk_colormap_get_system(), &rectangle->bg);
rectangle->line.line_style = GTK_PLOT_LINE_SOLID;
rectangle->line.line_width = 0;
rectangle->shadow_width = 3;
rectangle->border = GTK_PLOT_BORDER_LINE;
rectangle->filled = TRUE;
}
static void get_alpha_mask(float_shape_t *shape)
{
GdkColormap *colormap;
GdkColor black;
GdkColor white;
GdkGC *gc;
int rowstride, nchannels, x, y;
guchar *pixels, *p;
bool bright_green, has_alpha;
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
shape->mask_bitmap =
(GdkDrawable*)gdk_pixmap_new(NULL, shape->width, shape->height, 1);
gc = gdk_gc_new(shape->mask_bitmap);
gdk_gc_set_foreground(gc, &black);
gdk_gc_set_background(gc, &white);
gdk_draw_rectangle(shape->mask_bitmap, gc, TRUE, 0, 0,
shape->width, shape->height);
nchannels = gdk_pixbuf_get_n_channels(shape->pixbuf);
g_assert(gdk_pixbuf_get_colorspace(shape->pixbuf) == GDK_COLORSPACE_RGB);
g_assert(gdk_pixbuf_get_bits_per_sample(shape->pixbuf) == 8);
has_alpha = gdk_pixbuf_get_has_alpha(shape->pixbuf);
rowstride = gdk_pixbuf_get_rowstride(shape->pixbuf);
pixels = gdk_pixbuf_get_pixels(shape->pixbuf);
gdk_gc_set_foreground(gc, &white);
gdk_gc_set_background(gc, &black);
for (y = 0; y < shape->height; y++) {
for (x = 0; x < shape->width; x++) {
p = pixels + y*rowstride + x*nchannels;
bright_green = 0 == p[0] && 255 == p[1] && 0 == p[2];
if (has_alpha) {
if (255 == p[3]) // p[3] is alpha channel
gdk_draw_point(shape->mask_bitmap, gc, x, y);
}
else if (!bright_green) { // Bright green is alpha for RGB images
gdk_draw_point(shape->mask_bitmap, gc, x, y);
}
}
}
}
static void
gtk_plot_canvas_text_init (GtkPlotCanvasText *text)
{
GtkPlotText *text_attr;
text_attr = &text->text;
text_attr->angle = 0;
gdk_color_black(gdk_colormap_get_system(), &text_attr->fg);
gdk_color_white(gdk_colormap_get_system(), &text_attr->bg);
text_attr->justification = GTK_JUSTIFY_LEFT;
text_attr->transparent = TRUE;
text_attr->border = 0;
text_attr->border_width = 0;
text_attr->shadow_width = 0;
text_attr->text = NULL;
GTK_PLOT_CANVAS_CHILD(text)->flags = GTK_PLOT_CANVAS_CAN_MOVE;
}
static void
gtk_plot_candle_init (GtkPlotCandle *dataset)
{
GtkWidget *widget;
GdkColor black, white;
GdkColormap *colormap;
GtkPlotArray *dim;
widget = GTK_WIDGET(dataset);
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
GTK_PLOT_DATA(dataset)->symbol.symbol_style = GTK_PLOT_SYMBOL_FILLED;
GTK_PLOT_DATA(dataset)->symbol.color = white;
GTK_PLOT_DATA(dataset)->line.line_style = GTK_PLOT_LINE_SOLID;
GTK_PLOT_DATA(dataset)->line.line_width = 1;
GTK_PLOT_DATA(dataset)->line.color = black;
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "y");
gtk_plot_array_set_label(dim, "Open");
gtk_plot_array_set_description(dim, "Open");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "z");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "Close");
gtk_plot_array_set_description(dim, "Close");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "dy");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "Min");
gtk_plot_array_set_description(dim, "Minimum");
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "dz");
gtk_plot_array_set_required(dim, TRUE);
gtk_plot_array_set_label(dim, "Max");
gtk_plot_array_set_description(dim, "Maximum");
}
int config_dialog(char* title, int argc, char** argv) {
GtkWidget *box1, *but_quit, *but_start;
GdkBitmap *mask;
GdkPixmap *background;
GdkColormap* colormap;
GdkColor white, black;
if (gtk_init_check(&argc, &argv) == FALSE)
return -1;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable(GTK_WIDGET(window), TRUE);
gtk_window_set_title(GTK_WINDOW(window), title);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_widget_set_usize(GTK_WIDGET(window), 120, 400);
gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
box1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box1);
ch_windowed = gtk_check_button_new_with_label("Windowed");
gtk_box_pack_start(GTK_BOX(box1), ch_windowed, FALSE, FALSE, 0);
gtk_widget_show(ch_windowed);
ch_oldskool = gtk_check_button_new_with_label("Oldskool");
gtk_box_pack_start(GTK_BOX(box1), ch_oldskool, FALSE, FALSE, 0);
gtk_widget_show(ch_oldskool);
but_quit = gtk_button_new_with_label("Quit");
gtk_box_pack_end(GTK_BOX(box1), but_quit, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(but_quit), "clicked", GTK_SIGNAL_FUNC(quit_event), NULL);
gtk_widget_show(but_quit);
but_start = gtk_button_new_with_label("Start");
gtk_box_pack_end(GTK_BOX(box1), but_start, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(but_start), "clicked", GTK_SIGNAL_FUNC(start_event), NULL);
gtk_widget_show(but_start);
gtk_widget_show(box1);
gtk_widget_realize(GTK_WIDGET(window));
gdk_window_set_decorations(GTK_WIDGET(window)->window, 0);
colormap = gdk_colormap_get_system();
gdk_color_white(colormap, &white);
gdk_color_black(colormap, &black);
background = gdk_pixmap_create_from_data(GTK_WIDGET(window)->window,
fznback2_bits, fznback2_width, fznback2_height, -1, &black, &white);
gdk_window_set_back_pixmap(GTK_WIDGET(window)->window, background, FALSE);
gdk_window_clear(GTK_WIDGET(window)->window);
gtk_widget_show(window);
gtk_main();
return result;
}
void
ghid_set_color (hidGC gc, const char *name)
{
static void *cache = 0;
hidval cval;
if (name == NULL)
{
fprintf (stderr, "%s(): name = NULL, setting to magenta\n",
__FUNCTION__);
name = "magenta";
}
gc->colorname = (char *) name;
if (!gc->gc)
return;
if (gport->colormap == 0)
gport->colormap = gtk_widget_get_colormap (gport->top_window);
if (strcmp (name, "erase") == 0)
{
gdk_gc_set_foreground (gc->gc, &gport->bg_color);
gc->erase = 1;
}
else if (strcmp (name, "drill") == 0)
{
gdk_gc_set_foreground (gc->gc, &gport->offlimits_color);
gc->erase = 0;
}
else
{
ColorCache *cc;
if (hid_cache_color (0, name, &cval, &cache))
cc = (ColorCache *) cval.ptr;
else
{
cc = (ColorCache *) malloc (sizeof (ColorCache));
memset (cc, 0, sizeof (*cc));
cval.ptr = cc;
hid_cache_color (1, name, &cval, &cache);
}
if (!cc->color_set)
{
if (gdk_color_parse (name, &cc->color))
gdk_color_alloc (gport->colormap, &cc->color);
else
gdk_color_white (gport->colormap, &cc->color);
cc->color_set = 1;
}
if (gc->xor_mask)
{
if (!cc->xor_set)
{
cc->xor_color.red = cc->color.red ^ gport->bg_color.red;
cc->xor_color.green = cc->color.green ^ gport->bg_color.green;
cc->xor_color.blue = cc->color.blue ^ gport->bg_color.blue;
gdk_color_alloc (gport->colormap, &cc->xor_color);
cc->xor_set = 1;
}
gdk_gc_set_foreground (gc->gc, &cc->xor_color);
}
else
{
gdk_gc_set_foreground (gc->gc, &cc->color);
}
gc->erase = 0;
}
}
CAMLprim value ml_gdk_color_white (value cmap)
{
GdkColor color;
gdk_color_white (GdkColormap_val(cmap), &color);
return Val_copy(color);
}
static void file_info_box_build()
{
GtkWidget *hbox1, *vbox1;
GtkWidget *info_exit, *info_mute;
GtkWidget *info_unmute, *info_about;
GtkWidget *scrw1;
GtkWidget *expander;
GdkVisual *visual;
PangoFontDescription *desc;
info_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_object_set_data(GTK_OBJECT(info_window),
"info_window", info_window);
gtk_window_set_title(GTK_WINDOW(info_window),"Extended Module Player");
gtk_window_set_policy(GTK_WINDOW(info_window), FALSE, FALSE, TRUE);
gtk_signal_connect(GTK_OBJECT(info_window), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed), &info_window);
gtk_container_border_width(GTK_CONTAINER(info_window), 0);
gtk_widget_realize (info_window);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(info_window), vbox1);
gtk_object_set_data(GTK_OBJECT(vbox1), "vbox1", vbox1);
gtk_container_border_width(GTK_CONTAINER(vbox1), 4);
visual = gdk_visual_get_system();
/*
* Image
*/
frame1 = gtk_event_box_new();
gtk_object_set_data(GTK_OBJECT(frame1), "frame1", frame1);
gtk_widget_set_size_request(frame1, 300, 128);
gtk_box_pack_start(GTK_BOX(vbox1), frame1, FALSE, FALSE, 0);
image = gdk_image_new(GDK_IMAGE_FASTEST, visual, 300, 128);
ximage = GDK_IMAGE_XIMAGE(image);
image1 = gtk_image_new_from_image(image, NULL);
gtk_object_set_data(GTK_OBJECT(image1), "image1", image1);
gtk_container_add (GTK_CONTAINER(frame1), image1);
gtk_widget_set_events (frame1, GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK);
gtk_signal_connect (GTK_OBJECT (frame1), "button_press_event",
(GtkSignalFunc)image1_clicked, NULL);
/*
* Buttons
*/
hbox1 = gtk_hbox_new (TRUE, 0);
gtk_object_set_data(GTK_OBJECT(hbox1), "hbox1", hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, FALSE, 0);
info_mute = gtk_button_new_with_label("Mute");
gtk_signal_connect (GTK_OBJECT (info_mute), "clicked",
(GtkSignalFunc) button_mute, NULL);
gtk_object_set_data(GTK_OBJECT(info_mute), "info_mute", info_mute);
gtk_box_pack_start(GTK_BOX(hbox1), info_mute, TRUE, TRUE, 0);
info_unmute = gtk_button_new_with_label("Unmute");
gtk_signal_connect (GTK_OBJECT (info_unmute), "clicked",
(GtkSignalFunc) button_unmute, NULL);
gtk_object_set_data(GTK_OBJECT(info_unmute), "info_unmute", info_unmute);
gtk_box_pack_start(GTK_BOX(hbox1), info_unmute, TRUE, TRUE, 0);
info_about = gtk_button_new_with_label("About");
gtk_signal_connect_object(GTK_OBJECT(info_about), "clicked",
(GtkSignalFunc) aboutbox, NULL);
gtk_object_set_data(GTK_OBJECT(info_about), "info_about", info_about);
gtk_box_pack_start(GTK_BOX(hbox1), info_about, TRUE, TRUE, 0);
info_exit = gtk_button_new_with_label("Close");
gtk_signal_connect_object(GTK_OBJECT(info_exit), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_hide), GTK_OBJECT(info_window));
gtk_object_set_data(GTK_OBJECT(info_exit), "info_exit", info_exit);
gtk_box_pack_start(GTK_BOX(hbox1), info_exit, TRUE, TRUE, 0);
/*
* Info area
*/
expander = gtk_expander_new("Module information");
scrw1 = gtk_scrolled_window_new(NULL, NULL);
gtk_object_set_data(GTK_OBJECT(scrw1), "scrw1", scrw1);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrw1),
GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(expander), scrw1);
gtk_box_pack_start(GTK_BOX(vbox1), expander, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrw1, 290, 200);
text1b = gtk_text_buffer_new(NULL);
text1 = gtk_text_view_new_with_buffer(text1b);
desc = pango_font_description_new();
pango_font_description_set_family(desc, "Monospace");
gtk_widget_modify_font(text1, desc);
pango_font_description_free(desc);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text1), GTK_WRAP_NONE);
gtk_object_set_data(GTK_OBJECT(text1), "text1", text1);
gtk_container_add(GTK_CONTAINER(scrw1), text1);
gtk_widget_realize(text1);
gtk_widget_realize(image1);
display = GDK_WINDOW_XDISPLAY(info_window->window);
window = GDK_WINDOW_XWINDOW(info_window->window);
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, color_black);
gdk_color_white(colormap, color_white);
init_visual(visual);
set_palette();
clear_screen();
ii->wresult = 0;
panel_setup();
gtk_timeout_add(50, (GtkFunction)panel_loop, NULL);
}
static void
gtk_plot_gdk_draw_string (GtkPlotPC *pc,
gint tx, gint ty,
gint angle,
const GdkColor *fg,
const GdkColor *bg,
gboolean transparent,
gint border,
gint border_space,
gint border_width,
gint shadow_width,
const gchar *font_name,
gint font_height,
GtkJustification just,
const gchar *text)
{
GdkBitmap *text_bitmap;
GdkPixmap *text_pixmap;
GdkBitmap *text_mask;
GdkImage *image;
GdkGC *gc, *bitmap_gc;
GdkColormap *colormap;
GdkColor white, black, mask_color;
GList *family = NULL;
gint y0;
gint old_width, old_height;
gboolean bold, italic;
gint fontsize;
gint ascent, descent;
gint numf;
gint xp = 0, yp = 0;
gint width, height;
gint x, y;
gint i;
GdkFont *font, *latin_font, *dfont;
GtkPSFont *psfont, *base_psfont, *latin_psfont;
gchar subs[2], insert_char;
GdkWChar *aux, *wtext, *lastchar = NULL, *xaux;
gchar num[4];
if(!GTK_PLOT_GDK(pc)->drawable) return;
if(!GTK_PLOT_GDK(pc)->window) return;
if(!GTK_PLOT_GDK(pc)->gc) return;
if(!text || strlen(text) == 0) return;
colormap = gdk_colormap_get_system ();
gc = GTK_PLOT_GDK(pc)->gc;
if(!gc) return;
gtk_plot_text_get_size(text, angle, font_name, font_height, &width, &height, &ascent, &descent);
if(height == 0 || width == 0) return;
old_width = width;
old_height = height;
if(angle == 90 || angle == 270)
{
old_width = height;
old_height = width;
}
gtk_psfont_get_families(&family, &numf);
font = gtk_psfont_get_gdkfont(font_name, font_height);
base_psfont = psfont = gtk_psfont_get_font(font_name);
italic = psfont->italic;
bold = psfont->bold;
fontsize = font_height;
x = 0;
y0 = y = ascent;
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic,
bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize);
} else {
latin_psfont = NULL;
latin_font = NULL;
}
i = strlen(text) + 2;
aux = wtext = g_malloc0(sizeof(GdkWChar) * i);
gdk_mbstowcs(wtext, text, i - 1);
/* initializing text bitmap - ajd */
text_bitmap = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window,
old_width, old_height, 1);
bitmap_gc = gdk_gc_new(text_bitmap);
gdk_color_white (colormap, &white);
gdk_gc_set_foreground(bitmap_gc, &white);
gdk_draw_rectangle(text_bitmap, bitmap_gc, TRUE,
0, 0, -1, -1);
gdk_color_black (colormap, &black);
gdk_gc_set_foreground(bitmap_gc, &black);
while(aux && *aux != '\0' && *aux != '\n'){
if(*aux == '\\'){
aux++;
switch(*aux){
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7': case '9':
psfont = gtk_psfont_find_by_family((gchar *)g_list_nth_data(family, *aux-'0'), italic, bold);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
aux++;
break;
case '8': case 'g':
psfont = gtk_psfont_find_by_family("Symbol", italic, bold);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
aux++;
break;
case 'B':
bold = TRUE;
psfont = gtk_psfont_find_by_family(psfont->family, italic, bold);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 'x':
xaux = aux + 1;
for (i=0; i<3; i++){
if (xaux[i] >= '0' && xaux[i] <= '9')
num[i] = xaux[i];
else
break;
}
if (i < 3){
aux++;
break;
}
num[3] = '\0';
insert_char = (gchar)atoi(num);
subs[0] = insert_char;
subs[1] = '\0';
/* \xNNN is always outputted with latin fonts. */
dfont = (psfont->i18n_latinfamily != NULL) ? latin_font : font;
gdk_draw_string (text_bitmap, dfont,
bitmap_gc,
x, y,
subs);
x += gdk_char_width(font, insert_char);
aux += 4;
lastchar = aux - 1;
break;
case 'i':
italic = TRUE;
psfont = gtk_psfont_find_by_family(psfont->family, italic, bold);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 'S': case '^':
fontsize = (int)((gdouble)fontsize * 0.6 + 0.5);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
y -= font->ascent;
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 's': case '_':
fontsize = (int)((gdouble)fontsize * 0.6 + 0.5);
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
y += font->descent;
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case '+':
fontsize += 3;
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case '-':
fontsize -= 3;
gdk_font_unref(font);
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 'N':
psfont = base_psfont;
gdk_font_unref(font);
fontsize = font_height;
font = gtk_psfont_get_gdkfont(psfont->psname, fontsize);
y = y0;
italic = psfont->italic;
bold = psfont->bold;
if (latin_font) {
gdk_font_unref(latin_font);
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily,
italic, bold);
latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname,
fontsize);
}
aux++;
break;
case 'b':
if (lastchar) {
gtk_psfont_get_char_size(psfont, font, latin_font, *lastchar, &i,
NULL, NULL);
x -= i;
if (lastchar == wtext)
lastchar = NULL;
else
lastchar--;
} else {
gtk_psfont_get_char_size(psfont, font, latin_font, 'X', &i, NULL,
NULL);
x -= i;
}
aux++;
break;
default:
if(aux && *aux != '\0' && *aux !='\n'){
x += drawstring(pc, text_bitmap, bitmap_gc, &black, &white, x, y,
psfont, font, latin_font, *aux);
lastchar = aux;
aux++;
}
break;
}
} else {
if(aux && *aux != '\0' && *aux !='\n'){
x += drawstring(pc, text_bitmap, bitmap_gc, &black, &white, x, y,
psfont, font, latin_font, *aux);
lastchar = aux;
aux++;
}
}
}
g_free(wtext);
/* initializing clip mask bitmap - ajd */
text_mask = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window, width, height, 1);
mask_color = white;
mask_color.pixel = 0;
gdk_gc_set_foreground(bitmap_gc, &mask_color);
gdk_draw_rectangle(text_mask, bitmap_gc, TRUE, 0, 0, -1, -1);
mask_color = black;
mask_color.pixel = 1;
gdk_gc_set_foreground(bitmap_gc, &mask_color);
/* performing text rotation and saving it onto clip mask bitmap - ajd */
image = gdk_image_get(text_bitmap, 0, 0, old_width, old_height);
for(y = 0; y < old_height; y++)
for(x = 0; x < old_width; x++)
{
if( black.pixel == gdk_image_get_pixel(image, x, y) ){
switch(angle){
case 0:
xp = x;
yp = y;
break;
case 90:
xp = y;
yp = old_width - x;
break;
case 180:
xp = old_width - x;
yp = old_height - y;
break;
case 270:
xp = old_height - y;
yp = x;
break;
}
gdk_draw_point(text_mask, bitmap_gc, xp, yp);
}
}
gdk_image_destroy(image);
/* initializing text pixmap - ajd */
text_pixmap = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window, width, height, -1);
gdk_gc_set_foreground(gc, (GdkColor *) bg);
gdk_draw_rectangle(text_pixmap, gc, TRUE, 0, 0, -1, -1);
gdk_gc_set_foreground(gc, (GdkColor *) fg);
/* copying clip mask bitmap onto text pixmap - ajd */
gdk_gc_set_clip_mask(gc, text_mask);
gdk_gc_set_clip_origin(gc, 0, 0);
gdk_draw_rectangle(text_pixmap, gc, TRUE, 0, 0, -1, -1);
gdk_gc_set_clip_mask(gc, NULL);
gtk_plot_text_get_area(text, angle, just, font_name, font_height,
&x, &y, &width, &height);
tx += x;
ty += y;
if(transparent){
gdk_gc_set_clip_mask (gc, text_mask);
gdk_gc_set_clip_origin (gc, tx, ty);
} else {
gdk_gc_set_foreground(gc, (GdkColor *) bg);
gtk_plot_pc_draw_rectangle(pc,
TRUE,
tx - border_space, ty - border_space,
width + 2*border_space, height + 2*border_space);
}
gdk_draw_pixmap(GTK_PLOT_GDK(pc)->drawable, gc,
text_pixmap, 0, 0,
tx, ty, -1, -1);
gdk_gc_set_clip_mask(gc, NULL);
gdk_pixmap_unref(text_pixmap);
gdk_bitmap_unref(text_mask);
gdk_font_unref(font);
if (latin_font) gdk_font_unref(latin_font);
gdk_gc_unref(bitmap_gc);
gdk_pixmap_unref(text_bitmap);
/* border */
gdk_gc_set_foreground(gc, (GdkColor *) fg);
gtk_plot_pc_set_dash(pc, 0, NULL, 0);
gtk_plot_pc_set_lineattr(pc, border_width, 0, 0, 0);
switch(border){
case GTK_PLOT_BORDER_SHADOW:
gtk_plot_pc_draw_rectangle(pc,
TRUE,
tx - border_space + shadow_width,
ty + height + border_space,
width + 2 * border_space, shadow_width);
gtk_plot_pc_draw_rectangle(pc,
TRUE,
tx + width + border_space,
ty - border_space + shadow_width,
shadow_width, height + 2 * border_space);
case GTK_PLOT_BORDER_LINE:
gtk_plot_pc_draw_rectangle(pc,
FALSE,
tx - border_space, ty - border_space,
width + 2*border_space, height + 2*border_space);
case GTK_PLOT_BORDER_NONE:
default:
break;
}
return;
}
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;
}
