/**
* ppg_ruler_size_allocate:
* @ruler: (in): A #PpgRuler.
*
* Handle the "size-allocate" for the #GtkWidget. The pixmap for the
* background is created and drawn if necessary.
*
* Returns: None.
* Side effects: None.
*/
static void
ppg_ruler_size_allocate (GtkWidget *widget,
GtkAllocation *alloc)
{
PpgRuler *ruler = (PpgRuler *)widget;
PpgRulerPrivate *priv;
GdkColormap *colormap;
GdkVisual *visual;
g_return_if_fail(PPG_IS_RULER(ruler));
priv = ruler->priv;
GTK_WIDGET_CLASS(ppg_ruler_parent_class)->size_allocate(widget, alloc);
if (priv->ruler) {
g_object_unref(priv->ruler);
}
priv->ruler = gdk_pixmap_new(NULL, alloc->width, alloc->height, 32);
visual = gdk_visual_get_best_with_depth(32);
colormap = gdk_colormap_new(visual, FALSE);
gdk_drawable_set_colormap(priv->ruler, colormap);
if (GTK_WIDGET_DRAWABLE(widget)) {
ppg_ruler_draw_ruler(ruler);
}
}
/**
* ppg_ruler_realize:
* @widget: (in): A #PpgRuler.
*
* Handle the "realize" event for the widget.
*
* Returns: None.
* Side effects: None.
*/
static void
ppg_ruler_realize (GtkWidget *widget)
{
PpgRuler *ruler = (PpgRuler *)widget;
PpgRulerPrivate *priv;
GdkColormap *colormap;
GdkVisual *visual;
g_return_if_fail(PPG_IS_RULER(ruler));
priv = ruler->priv;
GTK_WIDGET_CLASS(ppg_ruler_parent_class)->realize(widget);
gtk_widget_queue_resize(widget);
/*
* Create pixmap for arrow.
*/
if (priv->arrow) {
g_object_unref(priv->arrow);
}
priv->arrow = gdk_pixmap_new(NULL, ARROW_SIZE, ARROW_SIZE, 32);
visual = gdk_visual_get_best_with_depth(32);
colormap = gdk_colormap_new(visual, FALSE);
gdk_drawable_set_colormap(priv->arrow, colormap);
}
/* Visual */
CAMLprim value ml_gdk_visual_get_best (value depth, value type)
{
GdkVisual *vis;
if (type == Val_unit)
if (depth == Val_unit) vis = gdk_visual_get_best ();
else vis = gdk_visual_get_best_with_depth (Int_val(Field(depth,0)));
else
if (depth == Val_unit)
vis = gdk_visual_get_best_with_type
(GdkVisualType_val(Field(type,0)));
else vis = gdk_visual_get_best_with_both
(Int_val(Field(depth,0)),GdkVisualType_val(Field(type,0)));
if (!vis) ml_raise_gdk("Gdk.Visual.get_best");
return Val_GdkVisual(vis);
}
static XImage * drawtheme_calc_alpha ( MCThemeDrawInfo &p_info)
{
XImage *t_bm_black ;
XImage *t_bm_white ;
GdkPixmap *t_black ;
GdkPixmap *t_white ;
GdkColormap *cm ;
GdkVisual *best_vis ;
uint4 t_w ;
uint4 t_h ;
t_w = p_info.drect.width ;
t_h = p_info.drect.height ;
// MM-2013-11-06: [[ Bug 11360 ]] Make sure we take into account the screen depth when creating pixmaps.
uint4 t_screen_depth;
t_screen_depth = ((MCScreenDC*) MCscreen) -> getdepth();
// Create two new pixmaps
t_black = gdk_pixmap_new( NULL, t_w, t_h, t_screen_depth);
t_white = gdk_pixmap_new( NULL, t_w, t_h, t_screen_depth);
// We need to attach a colourmap to the Drawables in GDK
best_vis = gdk_visual_get_best_with_depth(t_screen_depth);
cm = gdk_colormap_new( best_vis , False ) ;
gdk_drawable_set_colormap( t_black, cm);
gdk_drawable_set_colormap( t_white, cm);
//gdk_flush();
// Render solid black into one and white into the other.
//black_and_white_masks ( gdk_x11_drawable_get_xid( t_black ) , gdk_x11_drawable_get_xid(t_white));
fill_gdk_drawable(t_black, cm, 0, 0, 0, t_w, t_h);
fill_gdk_drawable(t_white, cm, 65535, 65535, 65535, t_w, t_h);
MCThemeDrawInfo t_info;
t_info = p_info;
moz_gtk_widget_paint ( p_info.moztype, t_white , &t_info.drect, &t_info.cliprect, &t_info.state, t_info.flags ) ;
t_info = p_info;
moz_gtk_widget_paint ( p_info.moztype, t_black , &t_info.drect, &t_info.cliprect, &t_info.state, t_info.flags ) ;
gdk_flush();
// Get the byte data for each of these pixmaps
t_bm_black = ((MCScreenDC*)MCscreen) -> getimage ( gdk_x11_drawable_get_xid(t_black), 0, 0, t_w, t_h, False ) ;
t_bm_white = ((MCScreenDC*)MCscreen) -> getimage ( gdk_x11_drawable_get_xid(t_white), 0, 0, t_w, t_h, False ) ;
// Calculate the alpha from these two bitmaps --- the t_bm_black image now has full ARGB
calc_alpha_from_bitmaps ( t_bm_black, t_bm_white ) ;
// clean up.
g_object_unref( t_black ) ;
g_object_unref( t_white ) ;
g_object_unref( cm ) ;
return ( t_bm_black ) ;
}
static VALUE
rg_s_best_with_depth(G_GNUC_UNUSED VALUE self, VALUE depth)
{
return GOBJ2RVAL(gdk_visual_get_best_with_depth(NUM2INT(depth)));
}
static VALUE
rg_s_best_with_type(G_GNUC_UNUSED VALUE self, VALUE type)
{
return GOBJ2RVAL(gdk_visual_get_best_with_depth(
(GdkVisualType)GENUM2RVAL(type, GDK_TYPE_VISUAL_TYPE)));
}
static GdkPixbuf* drawtheme_calc_alpha (MCThemeDrawInfo &p_info)
{
GdkPixbuf *t_pb_black;
GdkPixbuf *t_pb_white;
GdkPixmap *t_black ;
GdkPixmap *t_white ;
GdkColormap *cm ;
GdkVisual *best_vis ;
uint4 t_w ;
uint4 t_h ;
t_w = p_info.drect.width ;
t_h = p_info.drect.height ;
// MM-2013-11-06: [[ Bug 11360 ]] Make sure we take into account the screen depth when creating pixmaps.
uint4 t_screen_depth;
t_screen_depth = ((MCScreenDC*) MCscreen) -> getdepth();
// Create two new pixmaps
t_black = gdk_pixmap_new(NULL, t_w, t_h, t_screen_depth);
t_white = gdk_pixmap_new(NULL, t_w, t_h, t_screen_depth);
// We need to attach a colourmap to the Drawables in GDK
best_vis = gdk_visual_get_best_with_depth(t_screen_depth);
if (best_vis == NULL)
return NULL;
cm = gdk_colormap_new(best_vis, FALSE) ;
gdk_drawable_set_colormap(t_black, cm);
gdk_drawable_set_colormap(t_white, cm);
// Render solid black into one and white into the other.
fill_gdk_drawable(t_black, cm, 0, 0, 0, t_w, t_h);
fill_gdk_drawable(t_white, cm, 65535, 65535, 65535, t_w, t_h);
MCThemeDrawInfo t_info;
t_info = p_info;
moz_gtk_widget_paint ( p_info.moztype, t_white , &t_info.drect, &t_info.cliprect, &t_info.state, t_info.flags ) ;
t_info = p_info;
moz_gtk_widget_paint ( p_info.moztype, t_black , &t_info.drect, &t_info.cliprect, &t_info.state, t_info.flags ) ;
gdk_flush();
// Convert the server-side pixmaps into client-side pixbufs. The black
// pixbuf will need to have an alpha channel so that we can fill it in.
t_pb_black = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, t_w, t_h);
if (t_pb_black == NULL)
return NULL;
t_pb_white = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, t_w, t_h);
if (t_pb_white == NULL)
return NULL;
t_pb_black = gdk_pixbuf_get_from_drawable(t_pb_black, t_black, NULL, 0, 0, 0, 0, t_w, t_h);
if (t_pb_black == NULL)
return NULL;
t_pb_white = gdk_pixbuf_get_from_drawable(t_pb_white, t_white, NULL, 0, 0, 0, 0, t_w, t_h);
if (t_pb_white == NULL)
return NULL;
// Calculate the alpha from these two bitmaps --- the t_bm_black image now has full ARGB
// Note that this also frees the t_pb_white pixbuf
calc_alpha_from_pixbufs(t_pb_black, t_pb_white);
// clean up.
g_object_unref(t_black);
g_object_unref(t_white);
g_object_unref(cm);
return t_pb_black;
}
int main(int argc, char *argv[]) {
//
GtkWidget *window;
GtkWidget *fixed;
GtkWidget *area;
//
gtk_init(&argc, &argv);
// Window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "gui");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
gtk_window_set_default_size(GTK_WINDOW(window), width, height);
printf("window ok\n");
// layout
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
printf("fixed ok\n");
// Image
GList *visuals = gdk_list_visuals();
void tst(gpointer data, gpointer udata) {
if (((GdkVisual*)data)->depth == 32)
printf("visual :\n\ttype = %d\n\ttype = %d\n\tdepth = %d\n\tbits/rgb = %d\n\torder = %d\n\tred = %08X\n\tgreen = %08X\n\tblue = %08X\n"
, ((GdkVisual*)data)->type
, ((GdkVisual*)data)->colormap_size
, ((GdkVisual*)data)->depth
, ((GdkVisual*)data)->bits_per_rgb
, ((GdkVisual*)data)->byte_order
, ((GdkVisual*)data)->red_mask
, ((GdkVisual*)data)->green_mask
, ((GdkVisual*)data)->blue_mask
);
}
g_list_foreach(visuals, &tst, NULL);
GdkVisual *visu = gdk_visual_get_best_with_depth(32);
ximg = gdk_image_new(GDK_IMAGE_SHARED, visu, width, height);
printf("GdkImage : bytes/pix = %d, linesize = %d, bits/pix = %d ; type %d (mem = %p)\n"
, ximg->bpp, ximg->bpl, ximg->bits_per_pixel
, ximg->type, ximg->mem
);
// GdkPixbufAnimation
//gtk_image_set_from_pixbuf
//
GdkColormap *dcm = gdk_colormap_new(visu, FALSE);
// drawing area
area = gtk_drawing_area_new();
gdk_drawable_set_colormap(window, dcm);
gdk_drawable_set_colormap(area, dcm);
gtk_drawing_area_size(GTK_DRAWING_AREA(area), width, height);
printf("area ok\n");
//
gtk_fixed_put(GTK_FIXED(fixed), area, 0, 0);
printf("fixed ok\n");
//
bgra_alloc650(&bgra, width, height);
bgra_origin650(&bgra, +width/2, +height/2);
bgra_scale650(&bgra, 1, -1);
printf("bgra alloc ok\n");
maj();
printf("bgra maj done, still (%p <- %p)\n", ximg->mem, bgra.data);
// // Ximg
// memcpy(ximg->mem, bgra.data, bgra.size);
// printf("mcpy done\n");
// Pixmap
GdkColor bg;
GdkColor fg;
fg.pixel = 0xff000000;
fg.red = 0;
fg.green = 0;
fg.blue = 0;
bg.pixel = 0xff000000;
bg.red = 0;
bg.green = 0;
bg.blue = 0;
pixmap = gdk_pixmap_create_from_data(
GTK_WINDOW(window)
, bgra.data
, width
, height
, 32
, &fg
, &bg
);
// img = gdk_pixbuf_new_from_data(
// (guchar*)bgra.data
// , GDK_COLORSPACE_RGB
// , TRUE
// , 8
// , width
// , height
// , width << 2
// , &pbd, NULL
// );
// printf("PixBuf new ok\n");
//
// Image
// frame = gtk_image_new_from_pixbuf(img);
//// frame = gtimg;
// gtk_fixed_put(GTK_FIXED(fixed), frame, 0, 0);
// printf("fixed ok\n");
// Events
g_signal_connect(area, "expose-event", G_CALLBACK (on_expose_event), NULL);
// g_signal_connect(frame, "expose-event", G_CALLBACK (on_expose_event), NULL);
g_signal_connect(window, "delete-event", G_CALLBACK (delete_event), NULL);
g_signal_connect(window, "destroy", G_CALLBACK (destroy), NULL);
printf("signals ok\n");
// Show
// gtk_widget_show(area);
gtk_widget_show(fixed);
gtk_widget_show_all(window);
printf("show ok\n");
// Timer
g_timeout_add(500, (GSourceFunc)time_handler, (gpointer)area);
printf("timer ok\n");
gtk_main();
return 0;
}
