static void
awn_tooltip_set_mask (AwnTooltip *tooltip, gint width, gint height)
{
GtkWidget *widget = GTK_WIDGET (tooltip);
if (gtk_widget_is_composited (widget) == FALSE)
{
GdkBitmap *shaped_bitmap;
shaped_bitmap = (GdkBitmap*) gdk_pixmap_new (NULL, width, height, 1);
if (shaped_bitmap)
{
cairo_t *cr = gdk_cairo_create (shaped_bitmap);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_translate (cr, 0.5, 0.5);
awn_cairo_rounded_rect (cr, 0, 0, width, height,
TOOLTIP_ROUND_RADIUS, ROUND_ALL);
cairo_fill (cr);
cairo_destroy (cr);
gtk_widget_shape_combine_mask (widget, NULL, 0, 0);
gtk_widget_shape_combine_mask (widget, shaped_bitmap, 0, 0);
g_object_unref (shaped_bitmap);
}
}
}
static void
update_shape (GtkTooltip *tooltip)
{
GdkBitmap *mask;
cairo_t *cr;
gint width, height, tooltip_radius;
gtk_widget_style_get (tooltip->window,
"tooltip-radius", &tooltip_radius,
NULL);
if (tooltip_radius == 0 ||
gtk_widget_is_composited (tooltip->window))
{
gtk_widget_shape_combine_mask (tooltip->window, NULL, 0, 0);
return;
}
gtk_window_get_size (GTK_WINDOW (tooltip->window), &width, &height);
mask = (GdkBitmap *) gdk_pixmap_new (NULL, width, height, 1);
cr = gdk_cairo_create (mask);
fill_background (tooltip->window, cr,
&tooltip->window->style->black,
&tooltip->window->style->black,
255);
gtk_widget_shape_combine_mask (tooltip->window, mask, 0, 0);
cairo_destroy (cr);
g_object_unref (mask);
}
static void update_shape(WindowData* windata)
{
GdkBitmap* mask;
cairo_t* cr;
if (windata->width == windata->last_width && windata->height == windata->last_height)
{
return;
}
if (windata->width == 0 || windata->height == 0)
{
#if GTK_CHECK_VERSION(3, 0, 0)
GtkAllocation allocation;
gtk_widget_get_allocation(windata->win, &allocation);
windata->width = MAX(allocation.width, 1);
windata->height = MAX(allocation.height, 1);
#else
windata->width = MAX(windata->win->allocation.width, 1);
windata->height = MAX(windata->win->allocation.height, 1);
#endif
}
if (windata->composited)
{
gtk_widget_shape_combine_mask(windata->win, NULL, 0, 0);
return;
}
windata->last_width = windata->width;
windata->last_height = windata->height;
mask = (GdkBitmap*) gdk_pixmap_new(NULL, windata->width, windata->height, 1);
if (mask == NULL)
{
return;
}
cr = gdk_cairo_create(mask);
if (cairo_status(cr) == CAIRO_STATUS_SUCCESS)
{
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgb(cr, 1.0f, 1.0f, 1.0f);
draw_round_rect(cr, 1.0f, DEFAULT_X0, DEFAULT_Y0, DEFAULT_RADIUS, windata->width, windata->height);
cairo_fill(cr);
gtk_widget_shape_combine_mask(windata->win, mask, 0, 0);
}
cairo_destroy(cr);
g_object_unref(mask);
}
static void
update_shape (GtkWidget* window,
gint radius,
gint shadow_size)
{
GdkBitmap* mask = NULL;
cairo_t* cr = NULL;
GtkAllocation allocation;
gdouble width;
gdouble height;
gtk_widget_get_allocation (window, &allocation);
width = (gdouble) allocation.width;
height = (gdouble) allocation.height;
if (g_composited)
{
/* remove any current shape-mask */
gtk_widget_shape_combine_mask (window, NULL, 0, 0);
return;
}
mask = (GdkBitmap*) gdk_pixmap_new (NULL, width, height, 1);
if (mask)
{
cr = gdk_cairo_create (mask);
if (cairo_status (cr) == CAIRO_STATUS_SUCCESS)
{
/* clear mask/context */
cairo_scale (cr, 1.0f, 1.0f);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
/* draw rounded rectangle shape/mask */
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgb (cr, 1.0f, 1.0f, 1.0f);
draw_round_rect (cr,
1.0f,
(gdouble) shadow_size,
(gdouble) shadow_size,
(gdouble) radius,
(gdouble) (width - 2 * shadow_size),
(gdouble) (height - 2 * shadow_size));
cairo_fill (cr);
cairo_destroy (cr);
/* remove any current shape-mask */
gtk_widget_shape_combine_mask (window, NULL, 0, 0);
/* set new shape-mask */
gtk_widget_shape_combine_mask (window, mask, 0, 0);
}
g_object_unref ((gpointer) mask);
}
}
static void set_trayicon_pixmap(TrayIconType icontype)
{
GdkPixmap *pixmap = NULL;
GdkBitmap *bitmap = NULL;
switch(icontype) {
case TRAYICON_NEW:
pixmap = newmail_pixmap;
bitmap = newmail_bitmap;
break;
case TRAYICON_NEWMARKED:
pixmap = newmarkedmail_pixmap;
bitmap = newmarkedmail_bitmap;
break;
case TRAYICON_UNREAD:
pixmap = unreadmail_pixmap;
bitmap = unreadmail_bitmap;
break;
case TRAYICON_UNREADMARKED:
pixmap = unreadmarkedmail_pixmap;
bitmap = unreadmarkedmail_bitmap;
break;
default:
pixmap = nomail_pixmap;
bitmap = nomail_bitmap;
break;
}
gtk_pixmap_set(GTK_PIXMAP(image), pixmap, bitmap);
gtk_widget_shape_combine_mask(GTK_WIDGET(trayicon), bitmap, GTK_WIDGET(image)->allocation.x, GTK_WIDGET(image)->allocation.y);
}
float_shape_t *make_shape_from_pixbuf(GdkPixbuf *pixbuf)
{
float_shape_t *s = alloc_shape();
s->x = 0;
s->y = 0;
s->pixbuf = pixbuf;
s->width = gdk_pixbuf_get_width(pixbuf);
s->height = gdk_pixbuf_get_height(pixbuf);
s->window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_decorated(GTK_WINDOW(s->window), FALSE);
gtk_window_set_title(GTK_WINDOW(s->window), "shape");
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(s->window), TRUE);
gtk_window_set_keep_above(GTK_WINDOW(s->window), TRUE);
s->image = gtk_image_new_from_pixbuf(pixbuf);
gtk_container_add(GTK_CONTAINER(s->window), s->image);
get_alpha_mask(s);
gtk_widget_shape_combine_mask(s->window, s->mask_bitmap, 0, 0);
g_signal_connect(G_OBJECT(s->window), "destroy",
G_CALLBACK(quit_callback), NULL);
return s;
}
static VALUE
rg_shape_combine_mask(VALUE self, VALUE shape_mask, VALUE offset_x, VALUE offset_y)
{
gtk_widget_shape_combine_mask(_SELF(self),
GDK_BITMAP(RVAL2GOBJ(shape_mask)),
NUM2INT(offset_x),
NUM2INT(offset_y));
return self;
}
static void
pop_win_size_allocate (GtkWidget *widget, GtkAllocation *allocation, gpointer data)
{
GdkBitmap *bitmap = NULL;
bitmap = get_chamfered_rectangle_bitmap(allocation->width,
allocation->height, 2);
if (bitmap) {
gtk_widget_shape_combine_mask(widget, bitmap, 0, 0);
g_object_unref(bitmap);
}
}
int
main(int argc, char **argv)
{
GtkWidget *image;
GdkBitmap *mask;
GdkPixbuf *pixbuf;
GdkGC *gc;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
pixbuf = gdk_pixbuf_new_from_file ("romeo.png",
NULL);
if (!pixbuf)
{
g_error ("Could not load image");
}
mask = gdk_pixmap_new (NULL,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
1);
gdk_pixbuf_render_threshold_alpha (pixbuf,
mask,
0, 0, 0, 0,
-1, -1,
127);
gtk_widget_shape_combine_mask (window,
mask,
0, 0);
image = gtk_image_new_from_pixbuf (pixbuf);
gtk_container_add (GTK_CONTAINER (window),
image);
gtk_widget_show_all (window);
g_timeout_add (10,
turn,
NULL);
gtk_main ();
}
static void
_on_composited_changed (GtkWidget *widget)
{
if (gtk_widget_is_composited (widget) == FALSE)
{
GtkAllocation alloc;
gtk_widget_get_allocation (widget, &alloc);
awn_tooltip_set_mask (AWN_TOOLTIP (widget), alloc.width, alloc.height);
}
else
{
gtk_widget_shape_combine_mask (widget, NULL, 0, 0);
}
}
void wxDropSource::PrepareIcon( int action, GdkDragContext *context )
{
// get the right icon to display
wxIcon *icon = NULL;
if ( action & GDK_ACTION_MOVE )
icon = &m_iconMove;
else if ( action & GDK_ACTION_COPY )
icon = &m_iconCopy;
else
icon = &m_iconNone;
GdkBitmap *mask;
if ( icon->GetMask() )
mask = icon->GetMask()->GetBitmap();
else
mask = NULL;
GdkPixmap *pixmap = icon->GetPixmap();
gint width,height;
gdk_window_get_size (pixmap, &width, &height);
GdkColormap *colormap = gtk_widget_get_colormap( m_widget );
gtk_widget_push_visual (gdk_colormap_get_visual (colormap));
gtk_widget_push_colormap (colormap);
m_iconWindow = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_events (m_iconWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_set_app_paintable (GTK_WIDGET (m_iconWindow), TRUE);
gtk_widget_pop_visual ();
gtk_widget_pop_colormap ();
gtk_widget_set_usize (m_iconWindow, width, height);
gtk_widget_realize (m_iconWindow);
gtk_signal_connect( GTK_OBJECT(m_iconWindow), "configure_event",
GTK_SIGNAL_FUNC(gtk_dnd_window_configure_callback), (gpointer)this );
gdk_window_set_back_pixmap (m_iconWindow->window, pixmap, FALSE);
if (mask)
gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0);
gtk_drag_set_icon_widget( context, m_iconWindow, 0, 0 );
}
/* desktopicon_update_transparency */
static void _desktopicon_update_transparency(DesktopIcon * desktopicon)
{
GdkPixbuf * icon;
int width;
int height;
int iwidth;
int iheight;
GdkBitmap * mask;
GdkBitmap * iconmask;
GdkGC * gc;
GdkColor black = { 0, 0, 0, 0 };
GdkColor white = { 0xffffffff, 0xffff, 0xffff, 0xffff };
GtkRequisition req;
int offset;
if((icon = gtk_image_get_pixbuf(GTK_IMAGE(desktopicon->image))) == NULL)
return; /* XXX report error */
gtk_window_get_size(GTK_WINDOW(desktopicon->window), &width, &height);
iwidth = gdk_pixbuf_get_width(icon);
iheight = gdk_pixbuf_get_height(icon);
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s(\"%s\") window is %dx%d\n", __func__,
desktopicon->name, width, height);
#endif
mask = gdk_pixmap_new(NULL, width, height, 1);
gdk_pixbuf_render_pixmap_and_mask(icon, NULL, &iconmask, 255);
gc = gdk_gc_new(mask);
gdk_gc_set_foreground(gc, &black);
gdk_draw_rectangle(mask, gc, TRUE, 0, 0, width, height);
gdk_draw_drawable(mask, gc, iconmask, 0, 0, (width - iwidth) / 2,
(DESKTOPICON_ICON_SIZE - iheight) / 2, -1, -1);
gdk_gc_set_foreground(gc, &white);
gtk_widget_size_request(desktopicon->label, &req);
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s(\"%s\") label is %dx%d\n", __func__,
desktopicon->name, req.width, req.height);
#endif
offset = DESKTOPICON_ICON_SIZE + 4;
gdk_draw_rectangle(mask, gc, TRUE, (width - req.width - 8) / 2,
offset /* + ((height - offset - req.height - 8)
/ 2) */, req.width + 8, req.height + 8);
gtk_widget_shape_combine_mask(desktopicon->window, mask, 0, 0);
g_object_unref(gc);
g_object_unref(iconmask);
g_object_unref(mask);
}
int main (int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window, *pixmap, *fixed;
GdkPixmap *gdk_pixmap;
GdkBitmap *mask;
GtkStyle *style;
GdkGC *gc;
/* Create the main window, and attach delete_event signal to terminate
* the application. Note that the main window will not have a titlebar
* since we're making it a popup. */
gtk_init (&argc, &argv);
window = gtk_window_new( GTK_WINDOW_POPUP );
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (close_application), NULL);
gtk_widget_show (window);
/* Now for the pixmap and the pixmap widget */
style = gtk_widget_get_default_style();
gc = style->black_gc;
gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
WheelbarrowFull_xpm );
pixmap = gtk_pixmap_new( gdk_pixmap, mask );
gtk_widget_show( pixmap );
/* To display the pixmap, we use a fixed widget to place the pixmap */
fixed = gtk_fixed_new();
gtk_widget_set_usize( fixed, 200, 200 );
gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
gtk_container_add( GTK_CONTAINER(window), fixed );
gtk_widget_show( fixed );
/* This masks out everything except for the image itself */
gtk_widget_shape_combine_mask( window, mask, 0, 0 );
/* show the window */
gtk_widget_set_uposition( window, 20, 400 );
gtk_widget_show( window );
gtk_main ();
return(0);
}
static int gtkDialogSetOpacityImageAttrib(Ihandle *ih, const char *value)
{
GdkPixbuf* pixbuf = iupImageGetImage(value, ih, 0);
if (pixbuf)
{
#if GTK_CHECK_VERSION(3, 0, 0)
GdkWindow* window = iupgtkGetWindow(ih->handle);
if (window)
{
cairo_region_t *shape;
#if GTK_CHECK_VERSION(3, 10, 0)
cairo_surface_t* surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, 0, window);
#else
int width = gdk_pixbuf_get_width(pixbuf);
int height = gdk_pixbuf_get_height(pixbuf);
cairo_surface_t* surface = gdk_window_create_similar_surface(window, CAIRO_CONTENT_COLOR_ALPHA, width, height);
cairo_t* cr = cairo_create(surface);
gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_paint(cr);
cairo_destroy(cr);
#endif
shape = gdk_cairo_region_create_from_surface(surface);
cairo_surface_destroy(surface);
gtk_widget_shape_combine_region(ih->handle, shape);
cairo_region_destroy(shape);
}
#else
GdkBitmap* mask = NULL;
gdk_pixbuf_render_pixmap_and_mask(pixbuf, NULL, &mask, 255);
if (mask)
{
gtk_widget_shape_combine_mask(ih->handle, mask, 0, 0);
g_object_unref(mask);
}
#endif
return 1;
}
return 0;
}
static void
make_round_corners(panel *p)
{
GdkBitmap *b;
GdkGC* gc;
GdkColor black = { 0, 0, 0, 0};
GdkColor white = { 1, 0xffff, 0xffff, 0xffff};
int w, h, r, br;
ENTER;
w = p->aw;
h = p->ah;
r = p->round_corners_radius;
if (2*r > MIN(w, h)) {
r = MIN(w, h) / 2;
DBG("chaning radius to %d\n", r);
}
if (r < 4) {
DBG("radius too small\n");
RET();
}
b = gdk_pixmap_new(NULL, w, h, 1);
gc = gdk_gc_new(GDK_DRAWABLE(b));
gdk_gc_set_foreground(gc, &black);
gdk_draw_rectangle(GDK_DRAWABLE(b), gc, TRUE, 0, 0, w, h);
gdk_gc_set_foreground(gc, &white);
gdk_draw_rectangle(GDK_DRAWABLE(b), gc, TRUE, r, 0, w-2*r, h);
gdk_draw_rectangle(GDK_DRAWABLE(b), gc, TRUE, 0, r, r, h-2*r);
gdk_draw_rectangle(GDK_DRAWABLE(b), gc, TRUE, w-r, r, r, h-2*r);
br = 2 * r;
gdk_draw_arc(GDK_DRAWABLE(b), gc, TRUE, 0, 0, br, br, 0*64, 360*64);
gdk_draw_arc(GDK_DRAWABLE(b), gc, TRUE, 0, h-br-1, br, br, 0*64, 360*64);
gdk_draw_arc(GDK_DRAWABLE(b), gc, TRUE, w-br, 0, br, br, 0*64, 360*64);
gdk_draw_arc(GDK_DRAWABLE(b), gc, TRUE, w-br, h-br-1, br, br, 0*64, 360*64);
gtk_widget_shape_combine_mask(p->topgwin, b, 0, 0);
g_object_unref(gc);
g_object_unref(b);
RET();
}
void show_message(char *from, char *content)
{
debug("show_message(%s, %s)\n", from, content);
if (strlen(from) == 0 && strlen(content) == 0 ) {
gdk_window_resize(window->window, 1, 1);
return;
}
//初始化cairo环境
paint_message (cr, from, content);
cairo_surface_flush(sf);
//复制生成位图
copy_surface_to_pixmap (sf, pixmap);
copy_surface_to_pixmap (sf, pixmap_mask);
//刷新显示
gtk_window_set_title(GTK_WINDOW(window), content);
gdk_window_set_back_pixmap (window->window, pixmap, FALSE);
gtk_widget_shape_combine_mask (window, pixmap_mask, 0, 0);
gtk_widget_queue_draw(window);
gdk_window_resize(window->window, window_width, window_height);
}
/**
* @param stock_id a valid stock icon name
* @return a window showing the stock icon
*
* Create a window displaying a stock icon which is transparent
* according to the icon's alpha mask. Such windows are mostly
* useful to implement drag-and-drop operations with stock icons.
*/
GtkWidget*
gxk_stock_icon_window (const gchar *stock_id)
{
GtkWidget *drag_window, *image;
GdkPixbuf *pixbuf;
GdkBitmap *mask;
guint8 *bitmap_data;
gint width = 0, height = 0;
g_return_val_if_fail (stock_id != NULL, NULL);
pixbuf = gxk_stock_fallback_pixbuf (stock_id);
if (!pixbuf)
{
g_warning ("%s: unregistered stock id: \"%s\"", G_STRLOC, stock_id);
return NULL;
}
image = gtk_image_new_from_pixbuf (pixbuf);
gtk_widget_show (image);
drag_window = gtk_widget_new (GTK_TYPE_WINDOW,
"type", GTK_WINDOW_POPUP,
"child", image,
NULL);
gtk_widget_set_app_paintable (drag_window, TRUE);
gtk_widget_realize (drag_window);
gdk_window_raise (drag_window->window);
bitmap_data = gdk_pixbuf_create_bitmap_data (pixbuf, &width, &height, 1);
mask = gdk_bitmap_create_from_data (drag_window->window, bitmap_data, width, height);
g_free (bitmap_data);
gtk_widget_shape_combine_mask (drag_window, mask, 0, 0);
gdk_pixmap_unref (mask);
return drag_window;
}
static void create_win_message(char *icon, char *text, int duration)
{
GtkWidget *gwin_message = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(gwin_message), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (gwin_message), 0);
gtk_widget_realize (gwin_message);
GdkWindow *gdkwin = gtk_widget_get_window(gwin_message);
set_no_focus(gwin_message);
GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (gwin_message), hbox);
if (icon[0] != '-') {
GtkWidget *image = gtk_image_new_from_file(icon);
if (text[0] == '-') {
#if GTK_CHECK_VERSION(2,91,0)
GdkPixbuf *pixbuf = NULL;
GdkPixbufAnimation *anime = NULL;
switch(gtk_image_get_storage_type(GTK_IMAGE(image))) {
case GTK_IMAGE_PIXBUF:
pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
break;
case GTK_IMAGE_ANIMATION:
anime = gtk_image_get_animation(GTK_IMAGE(image));
pixbuf = gdk_pixbuf_animation_get_static_image(anime);
break;
default:
break;
}
cairo_surface_t *img = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
cairo_t *cr = cairo_create(img);
gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
cairo_paint(cr);
cairo_region_t *mask = gdk_cairo_region_create_from_surface(img);
gtk_widget_shape_combine_region(gwin_message, mask);
cairo_region_destroy(mask);
cairo_destroy(cr);
cairo_surface_destroy(img);
#else
GdkBitmap *bitmap = NULL;
gdk_pixbuf_render_pixmap_and_mask(gdk_pixbuf_new_from_file(icon, NULL), NULL, &bitmap, 128);
gtk_widget_shape_combine_mask(gwin_message, bitmap, 0, 0);
#endif
}
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
}
if (text[0] != '-') {
GtkWidget *label = gtk_label_new(text);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
}
gtk_widget_show_all(gwin_message);
int width, height;
get_win_size(gwin_message, &width, &height);
int ox=-1, oy;
int szx, szy;
if (tray_da_win) {
gdk_window_get_origin (tray_da_win, &ox, &oy);
#if !GTK_CHECK_VERSION(2,91,0)
gdk_drawable_get_size(tray_da_win, &szx, &szy);
#else
szx = gdk_window_get_width(tray_da_win);
szy = gdk_window_get_height(tray_da_win);
#endif
if (oy<height) {
oy = szy;
} else {
oy -= height;
if (oy + height > dpy_yl)
oy = dpy_yl - height;
if (oy < 0)
oy = 0;
}
if (ox + width > dpy_xl)
ox = dpy_xl - width;
if (ox < 0)
ox = 0;
} else
if (icon_main) {
GdkRectangle rect;
GtkOrientation ori;
if (gtk_status_icon_get_geometry(icon_main, NULL, &rect, &ori)) {
dbg("rect %d,%d\n", rect.x, rect.y, rect.width, rect.height);
if (ori==GTK_ORIENTATION_HORIZONTAL) {
ox=rect.x;
if (rect.y > 100)
oy=rect.y - height;
else
oy=rect.y + rect.height;
} else {
oy=rect.y;
if (rect.x > 100)
ox=rect.x - width;
else
ox=rect.x + rect.width;
}
}
}
if (ox < 0) {
ox = dpy_xl - width;
oy = dpy_yl - height;
}
gtk_window_move(GTK_WINDOW(gwin_message), ox, oy);
g_timeout_add(duration, (GSourceFunc)timeout_destroy_window, gwin_message);
}
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *image;
GtkWidget *fixed;
// GtkWidget *item;
GtkWidget *mainWindow;
GdkScreen* scr;
GdkBitmap *window_mask;
GdkPixmap *pixmap;
GdkBitmap *pixmap_mask;
int lang = get_lang();
switch(lang)
{
case 0:
item_labels[0] = g_strdup_printf("重启");
item_labels[1] = g_strdup_printf("待机");
item_labels[2] = g_strdup_printf("关机");
item_labels[3] = g_strdup_printf("取消");
break;
case 1:
item_labels[0] = g_strdup_printf("Restart");
item_labels[1] = g_strdup_printf("Stand By");
item_labels[2] = g_strdup_printf("Turn off");
item_labels[3] = g_strdup_printf("Cancel");
break;
case 2:
item_labels[0] = g_strdup_printf("再起動");
item_labels[1] = g_strdup_printf("スタンバイ");
item_labels[2] = g_strdup_printf("電源を切る");
item_labels[3] = g_strdup_printf("キャンセル");
break;
}
gtk_init(&argc, &argv);
//----------------------------------------------
mainWindow = gtk_window_new( GTK_WINDOW_POPUP);
scr = gtk_window_get_screen( GTK_WINDOW( mainWindow));
GdkColor white;
gdk_color_parse("#9c9c9c",&white);
gtk_widget_modify_bg(mainWindow,GTK_STATE_NORMAL,&white);
gtk_window_set_default_size( GTK_WINDOW( mainWindow),
gdk_screen_get_width( scr),
gdk_screen_get_height( scr));
//gtk_widget_set_size_request(mainWindow, window_width, window_height);
gtk_window_fullscreen( GTK_WINDOW( mainWindow));
gtk_widget_show_all( mainWindow);
gtk_widget_realize(GTK_WIDGET(mainWindow));
Display *xdpy = XOpenDisplay(getenv("DISPLAY"));
GdkWindow *gdkwin = GTK_WIDGET(mainWindow)->window;
Window xwin = GDK_WINDOW_XID(gdkwin);
unsigned int opacity = (unsigned int) (0.70 * OPAQUE);
XChangeProperty(xdpy, xwin, XInternAtom(xdpy, OPACITY, False),
XA_CARDINAL, 32, PropModeReplace,
(unsigned char *) &opacity, 1L);
// XSync(xdpy, False);
//----------------------------------------------
window = gtk_window_new(GTK_WINDOW_POPUP);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(destroy), NULL);
gtk_window_set_default_size(GTK_WINDOW(window), window_width, window_height);
//gtk_widget_set_size_request(window, window_width, window_height);
//gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_move(GTK_WINDOW(window), 249,163);
gtk_window_set_modal(window,FALSE);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_window_set_title (GTK_WINDOW (window),"CloseWindow");
/*gdk_pointer_grab (window->window, FALSE,
(GdkEventMask)EVENT_MASKS, 0,
NULL,
GDK_CURRENT_TIME);*/
gdk_pixmap_create_from_xpm(window->window, &window_mask, NULL, background_png);
gtk_widget_shape_combine_mask (window, window_mask, 0, 0);
gtk_widget_realize(GTK_WIDGET(window));
Display *xdpy2 = XOpenDisplay(getenv("DISPLAY"));
GdkWindow *gdkwin2 = GTK_WIDGET(window)->window;
Window xwin2 = GDK_WINDOW_XID(gdkwin2);
unsigned int opacity2 = (unsigned int) (0.80 * OPAQUE);
XChangeProperty(xdpy2, xwin2, XInternAtom(xdpy2, OPACITY, False),
XA_CARDINAL, 32, PropModeReplace,
(unsigned char *) &opacity2, 1L);
gtk_widget_show_all(window);
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
gtk_widget_show(fixed);
pixmap = gdk_pixmap_create_from_xpm(window->window, &pixmap_mask, NULL, background_png);
image = gtk_image_new_from_pixmap(pixmap, pixmap_mask);
gtk_fixed_put(GTK_FIXED(fixed), image, 0, 0);
gtk_widget_show(image);
make_icon_area(fixed);
//make_cancel_button(fixed);
XSync(xdpy, False);XSync(xdpy2, False);
gtk_main();
return 0;
}
bool wxSkinWindow::SetShape(const wxRegion& region)
{
#if defined(__WXMSW__) && !defined(__WXWINCE__)
// The empty region signifies that the shape should be removed from the
// window.
if ( region.IsEmpty() )
{
if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
{
wxLogLastError(_T("SetWindowRgn"));
return false;
}
return true;
}
DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL);
RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
::GetRegionData(GetHrgnOf(region), noBytes, rgnData);
HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData);
delete[] (char*) rgnData;
RECT rect;
DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
::GetClientRect(GetHwnd(), &rect);
::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
::OffsetRgn(hrgn, -rect.left, -rect.top);
if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
{
wxLogLastError(_T("SetWindowRgn"));
return false;
}
return true;
#elif defined(__WXMAC__)
if ( region.IsEmpty() )
{
wxSize sz = GetClientSize();
wxRegion rgn(0, 0, sz.x, sz.y);
return SetShape(rgn);
}
// Make a copy of the region
RgnHandle shapeRegion = NewRgn();
CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion );
// Dispose of any shape region we may already have
RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)GetHandle() );
if ( oldRgn )
DisposeRgn(oldRgn);
// Save the region so we can use it later
SetWRefCon((WindowRef)GetHandle(), (SInt32)shapeRegion);
// Tell the window manager that the window has changed shape
ReshapeCustomWindow((WindowRef)GetHandle());
return true;
#elif defined(__WXGTK__)
if(region.IsEmpty())
{
if(m_wxwindow && !GTK_WIDGET_NO_WINDOW(m_wxwindow))
gtk_widget_shape_combine_mask(m_wxwindow,NULL,0,0);
if(m_widget && !GTK_WIDGET_NO_WINDOW(m_widget))
gtk_widget_shape_combine_mask(m_widget,NULL,0,0);
}
else
{ wxBitmap bmp = region.ConvertToBitmap();
bmp.SetMask(new wxMask(bmp, *wxBLACK));
GdkBitmap* mask = bmp.GetMask()->GetBitmap();
if(m_wxwindow && !GTK_WIDGET_NO_WINDOW(m_wxwindow))
gtk_widget_shape_combine_mask(m_wxwindow,mask,0,0);
if(m_widget && !GTK_WIDGET_NO_WINDOW(m_widget))
gtk_widget_shape_combine_mask(m_widget,mask,0,0);
}
return true;
#else
return false;
#endif
}
static GtkWidget *
mnb_notification_gtk_create ()
{
GtkWidget *widget = NULL;
GtkWindow *window;
GtkWidget *evbox;
GdkPixbuf *pixbuf;
img_normal = gtk_image_new_from_file (THEMEDIR
"/notifiers/fscreen-notif-normal.png");
if (img_normal)
g_object_ref (img_normal);
img_hover = gtk_image_new_from_file (THEMEDIR
"/notifiers/fscreen-notif-hover.png");
if (img_hover)
g_object_ref (img_hover);
widget = gtk_window_new (GTK_WINDOW_POPUP);
window = GTK_WINDOW (widget);
pixbuf = gdk_pixbuf_new_from_file (THEMEDIR
"/notifiers/fscreen-notif-normal.png",
NULL);
if (pixbuf)
{
gint width, height, rowstride, channels;
guchar *pixels;
gint x, y;
GdkDrawable *mask;
GdkGC *gc;
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
pixels = gdk_pixbuf_get_pixels (pixbuf);
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
channels = gdk_pixbuf_get_n_channels (pixbuf);
g_assert (channels == 4);
mask = gdk_pixmap_new (NULL, width, height, 1);
gc = gdk_gc_new (mask);
for (x = 0; x < width; ++x)
for (y = 0; y < height; ++y)
{
GdkColor clr;
guchar *p = pixels + y * rowstride + x * channels;
if (p[3] == 0)
clr.pixel = 0;
else
clr.pixel = 1;
gdk_gc_set_foreground (gc, &clr);
gdk_draw_point (mask, gc, x, y);
}
gtk_widget_shape_combine_mask (widget, mask, 0, 0);
g_object_unref (mask);
g_object_unref (pixbuf);
g_object_unref (gc);
}
gtk_window_set_decorated (window, FALSE);
gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_window_set_resizable (window, FALSE);
gtk_window_set_title (window, "mnb-notification-gtk");
gtk_window_set_accept_focus (window, FALSE);
gtk_window_move (window, 20, 20);
evbox = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (evbox), FALSE);
gtk_event_box_set_above_child (GTK_EVENT_BOX (evbox), TRUE);
if (!img_normal)
{
gtk_container_add (GTK_CONTAINER (evbox),
gtk_button_new_with_label ("Notifications"));
}
else
{
gtk_container_add (GTK_CONTAINER (evbox), img_normal);
}
gtk_container_add (GTK_CONTAINER (window), evbox);
gtk_widget_show (evbox);
g_signal_connect (evbox, "button-press-event",
G_CALLBACK(mnb_notification_gtk_click_cb),
NULL);
if (img_normal && img_hover)
{
g_signal_connect (evbox, "enter-notify-event",
G_CALLBACK(mnb_notification_gtk_crossing_cb),
NULL);
g_signal_connect (evbox, "leave-notify-event",
G_CALLBACK(mnb_notification_gtk_crossing_cb),
NULL);
}
return widget;
}
int main (int argc, char *argv[] )
{
GtkWidget *window, *pixmap, *fixed;
GdkPixmap *gdk_pixmap;
GdkBitmap *mask;
GtkStyle *style;
GdkGC *gc;
CursorOffset* icon_pos;
//初始化
gtk_set_locale();
gtk_init (&argc, &argv);
//根窗口
root_win = gdk_window_foreign_new (GDK_ROOT_WINDOW ());
//建立无边界窗口
window = gtk_window_new( GTK_WINDOW_POPUP );
gtk_widget_set_events (window,
gtk_widget_get_events (window) |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_PRESS_MASK);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (close_application), NULL);
gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
GTK_SIGNAL_FUNC (shape_pressed),NULL);
gtk_signal_connect (GTK_OBJECT (window), "button_release_event",
GTK_SIGNAL_FUNC (shape_released),NULL);
gtk_signal_connect (GTK_OBJECT (window), "motion_notify_event",
GTK_SIGNAL_FUNC (shape_motion),NULL);
gtk_widget_show (window);
//建立图像
style = gtk_widget_get_default_style();
gc = style->black_gc;
gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window,
&mask, &style->bg[GTK_STATE_NORMAL],
xpenguin_color_xpm );
pixmap = gtk_pixmap_new( gdk_pixmap, mask );
gtk_widget_show( pixmap );
//建立一个定点定位容器
fixed = gtk_fixed_new();
//容器的尺寸和图像一样
gtk_widget_set_usize( fixed, 202, 240 );
gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
gtk_container_add( GTK_CONTAINER(window), fixed );
gtk_widget_show( fixed );
//对窗口设置掩码
gtk_widget_shape_combine_mask( window, mask, 0, 0 );
//设置数据
icon_pos = g_new (CursorOffset, 1);
gtk_object_set_user_data(GTK_OBJECT(window), icon_pos);
//设置窗口的位置
gtk_widget_set_uposition( window, 200, 400 );
gtk_widget_show( window );
gtk_main ();
return(0);
}
GtkWidget* registUI() {
GtkWidget* window;
GtkWidget* box;
GtkWidget* urnamebox;
GtkWidget* psdbox;
GtkWidget* repeatpsdbox;
GtkWidget* btnbox;
GtkWidget* urnamelabel;
GtkWidget* psdlabel;
GtkWidget* repeatpsdlabel;
GtkWidget* button;
GtkWidget* loginbtn;
GtkWidget* urname;
GtkWidget* password;
GtkWidget* rpassword;
GtkWidget* sep;
GtkWidget* main_box;
//图片buf
GdkPixbuf* pixbuf = NULL;
GdkPixmap* pixmap = NULL;
GdkBitmap* bitmap = NULL;
//
GtkWidget* vbox,*hbox;
GtkWidget* box1,*box2;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
main_box=gtk_vbox_new(FALSE,0);
vbox = gtk_vbox_new(FALSE,0);
hbox = gtk_hbox_new(FALSE,0);
box1 = gtk_vbox_new(FALSE,0);
box2 = gtk_vbox_new(FALSE,0);
gtk_window_set_decorated(GTK_WINDOW(window),FALSE);
//==========================显示小埋===============================
gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK);
gtk_widget_set_size_request(window, 844, 415);
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(window), "button_press_event", G_CALLBACK(window_drag), NULL);
pixbuf = gdk_pixbuf_new_from_file ("./xiaomai.png",NULL);
gdk_pixbuf_render_pixmap_and_mask(pixbuf, &pixmap, &bitmap, 128);
gtk_widget_shape_combine_mask(window, bitmap, 0, 0);
GtkStyle *style = gtk_style_copy(window->style);
if(style->bg_pixmap[GTK_STATE_NORMAL])
g_object_unref(style->bg_pixmap[GTK_STATE_NORMAL]);
style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref(pixmap);
gtk_widget_set_style(window, style);
//=====================================================================
gtk_widget_set_size_request(vbox,844,125);
gtk_box_pack_start(GTK_BOX(main_box),vbox,FALSE,FALSE,0);
gtk_widget_set_size_request(hbox,844,250);
gtk_box_pack_start(GTK_BOX(main_box),hbox,FALSE,FALSE,0);
gtk_widget_set_size_request(box1,350,250);
gtk_box_pack_start(GTK_BOX(hbox),box1,FALSE,FALSE,0);
gtk_widget_set_size_request(box2,316,250);
gtk_box_pack_start(GTK_BOX(hbox),box2,FALSE,FALSE,0);
gtk_window_set_title(GTK_WINDOW(window),"regist");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window),20);
gtk_container_add(GTK_CONTAINER(window),main_box);
//main box init
box = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(box2),box,FALSE,FALSE,5);
urnamebox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(box),urnamebox,FALSE,FALSE,5);
psdbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(box),psdbox,FALSE,FALSE,5);
repeatpsdbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(box),repeatpsdbox,FALSE,FALSE,5);
sep=gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(box),sep,FALSE,FALSE,5);
btnbox=gtk_hbox_new(TRUE,0);
gtk_box_pack_start(GTK_BOX(box),btnbox,FALSE,FALSE,5);
//uesrname box init
urnamelabel = gtk_label_new(" uesrname:");
urname=gtk_entry_new();
gtk_box_pack_end(GTK_BOX(urnamebox),urname,FALSE,FALSE,5);
gtk_box_pack_end(GTK_BOX(urnamebox),urnamelabel,FALSE,FALSE,5);
//password box init
psdlabel = gtk_label_new(" password:"******"confirm password:"******"regist");
loginbtn=gtk_button_new_with_label("return to login");
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(regist_on_button_clicked),®msg);
//g_signal_connect_swapped(G_OBJECT(button),"clicked",G_CALLBACK(gtk_widget_destroy),window);
g_signal_connect(G_OBJECT(loginbtn),"clicked",G_CALLBACK(regist_to_login_on_button_clicked),window);
gtk_box_pack_start(GTK_BOX(btnbox),button,FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(btnbox),loginbtn,FALSE,FALSE,5);
//gtk_widget_show_all(window);
//gtk_main();
return window;
}
void wxDropSource::PrepareIcon( int action, GdkDragContext *context )
{
// get the right icon to display
wxIcon *icon = NULL;
if ( action & GDK_ACTION_MOVE )
icon = &m_iconMove;
else if ( action & GDK_ACTION_COPY )
icon = &m_iconCopy;
else
icon = &m_iconNone;
#ifndef __WXGTK3__
GdkBitmap *mask;
if ( icon->GetMask() )
mask = *icon->GetMask();
else
mask = NULL;
GdkPixmap *pixmap = icon->GetPixmap();
GdkColormap *colormap = gtk_widget_get_colormap( m_widget );
gtk_widget_push_colormap (colormap);
#endif
m_iconWindow = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_events (m_iconWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_widget_set_app_paintable (m_iconWindow, TRUE);
#ifdef __WXGTK3__
gtk_widget_set_visual(m_iconWindow, gtk_widget_get_visual(m_widget));
#else
gtk_widget_pop_colormap ();
#endif
gtk_widget_set_size_request (m_iconWindow, icon->GetWidth(), icon->GetHeight());
gtk_widget_realize (m_iconWindow);
g_signal_connect (m_iconWindow, "configure_event",
G_CALLBACK (gtk_dnd_window_configure_callback), this);
#ifdef __WXGTK3__
cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(m_iconWindow));
icon->SetSourceSurface(cr, 0, 0);
cairo_pattern_t* pattern = cairo_get_source(cr);
gdk_window_set_background_pattern(gtk_widget_get_window(m_iconWindow), pattern);
cairo_destroy(cr);
cairo_surface_t* mask = NULL;
if (icon->GetMask())
mask = *icon->GetMask();
if (mask)
{
cairo_region_t* region = gdk_cairo_region_create_from_surface(mask);
gtk_widget_shape_combine_region(m_iconWindow, region);
cairo_region_destroy(region);
}
#else
gdk_window_set_back_pixmap(gtk_widget_get_window(m_iconWindow), pixmap, false);
if (mask)
gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0);
#endif
gtk_drag_set_icon_widget( context, m_iconWindow, 0, 0 );
}
static void update_shape(Osd * self)
{
gtk_widget_shape_combine_mask(GTK_WIDGET(self), self->mask, 0, 0);
}
void initGui( JunoControl* _junoControl,
Settings* _settings,
MidiInput* _midiInput,
int numVoices)
{
junoControl = _junoControl;
settings = _settings;
midiInput = _midiInput;
keyboard = new JunoKeyboard(numVoices);
mainMenu = gtk_item_factory_new(GTK_TYPE_MENU, "<Main>", NULL);
gtk_item_factory_create_items(mainMenu, mainwin_general_menu_entry_count,
mainwin_general_menu_entries, NULL);
GtkStyle* menuStyle = gtk_style_new(); // a default style
gtk_widget_set_style( mainMenu->widget, menuStyle );
GtkWidget* mainContainer;
mainWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_widget_add_events( GTK_WIDGET( mainWindow ),
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK );
gtk_window_set_default_size( GTK_WINDOW( mainWindow ), 940, 224 );
gtk_window_set_policy(GTK_WINDOW(mainWindow), FALSE, FALSE, TRUE);
gtk_widget_realize( mainWindow );
gdk_window_set_decorations( mainWindow->window, (GdkWMDecoration)0 );
gtk_widget_set_app_paintable(mainWindow, TRUE);
gtk_signal_connect(GTK_OBJECT(mainWindow), "button_press_event",
GTK_SIGNAL_FUNC(mainWindow_press), NULL);
gtk_signal_connect(GTK_OBJECT(mainWindow), "button_release_event",
GTK_SIGNAL_FUNC(mainWindow_release), NULL);
gtk_signal_connect(GTK_OBJECT(mainWindow), "motion_notify_event",
GTK_SIGNAL_FUNC(mainWindow_motion), NULL);
gtk_signal_connect(GTK_OBJECT(mainWindow), "enter_notify_event",
GTK_SIGNAL_FUNC(mainWindow_enter), NULL);
gtk_signal_connect(GTK_OBJECT(mainWindow), "leave_notify_event",
GTK_SIGNAL_FUNC(mainWindow_leave), NULL);
mainContainer = gtk_fixed_new();
gtk_widget_show( mainWindow );
gtk_widget_show( mainContainer );
GdkPixmap* image = gdk_pixmap_create_from_xpm_d( mainWindow->window,
NULL,
NULL,
juno_background_data );
GtkWidget* pixmap = gtk_pixmap_new( image, NULL );
gtk_widget_show( pixmap );
gtk_fixed_put( GTK_FIXED( mainContainer ), pixmap, 0, 0 );
gtk_container_add( GTK_CONTAINER( mainWindow ), mainContainer );
init();
layout( GTK_FIXED( mainContainer ) );
GdkBitmap* mask = gdk_bitmap_create_from_data( mainWindow->window,
juno_background_mask_bits,
juno_background_mask_width,
juno_background_mask_height );
gtk_widget_shape_combine_mask( mainWindow, mask, 0, 0 );
}
static void
egg_status_icon_update_image (EggStatusIcon *status_icon)
{
if (status_icon->priv->blink_off)
{
gtk_image_set_from_pixbuf (GTK_IMAGE (status_icon->priv->image),
egg_status_icon_blank_icon (status_icon));
return;
}
switch (status_icon->priv->image_type)
{
case GTK_IMAGE_PIXBUF:
{
GdkPixbuf *pixbuf;
pixbuf = status_icon->priv->image_data.pixbuf;
if (pixbuf)
{
GdkPixbuf *scaled;
gint size;
gint width;
gint height;
size = status_icon->priv->size;
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
if (width > size || height > size)
{
scaled = gdk_pixbuf_scale_simple (pixbuf,
MIN (size, width),
MIN (size, height),
GDK_INTERP_BILINEAR);
}
else
{
scaled = g_object_ref (pixbuf);
}
gtk_image_set_from_pixbuf (GTK_IMAGE (status_icon->priv->image), scaled);
/* Sets the icon's transparency mask as the window's shape mask.
Note: This doesn't handle translucency (partial transparency). */
gint image_offset_x, image_offset_y;
/* No way to know the image's real offset but by calculating ourselves. */
{
GtkOrientation orientation;
gfloat xalign, yalign;
gint xpad, ypad;
GtkWidget* image = status_icon->priv->image;
gtk_misc_get_padding(GTK_MISC(image), &xpad, &ypad);
gtk_misc_get_alignment(GTK_MISC(image), &xalign, &yalign);
/* We're aligning either horizontally or vertically, depending
on the orientation. According to this, we'll assume either
width or height to be preallocated up to the panel's size. */
orientation = egg_tray_icon_get_orientation (EGG_TRAY_ICON (status_icon->priv->tray_icon));
/* We base on the code found in gtk_image_expose */
image_offset_x = floor(image->allocation.x + xpad + ((status_icon->priv->alloc_width - image->requisition.width) * xalign) + 0.5);
image_offset_y = floor(image->allocation.y + ypad + ((status_icon->priv->alloc_height - image->requisition.height) * yalign) + 0.5);
}
GdkBitmap* scaled_mask = NULL;
gdk_pixbuf_render_pixmap_and_mask(scaled, NULL, &scaled_mask, 0);
if (scaled_mask)
{
/* It's only possible to set shape masks on real windows, so we have to set an offseted shape mask. */
gtk_widget_shape_combine_mask(GTK_WIDGET(status_icon->priv->tray_icon), scaled_mask, image_offset_x, image_offset_y);
g_object_unref(scaled_mask);
}
g_object_unref (scaled);
}
else
{
gtk_image_set_from_pixbuf (GTK_IMAGE (status_icon->priv->image), NULL);
}
}
break;
case GTK_IMAGE_STOCK:
case GTK_IMAGE_ANIMATION:
case GTK_IMAGE_EMPTY:
gtk_image_set_from_pixbuf (GTK_IMAGE (status_icon->priv->image), NULL);
break;
default:
g_assert_not_reached ();
break;
}
}
int main (int argc, char **argv)
{
gtk_init (&argc, &argv);
read_config ();
// Read options from command-line arguments.
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new (" - show X11 windows as colour mosaic");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_printerr ("option parsing failed: %s\n", error->message);
exit (1);
}
g_option_context_free (context);
if(options.format && !options.read_stdin) {
g_printerr("You must provide option --read-stdin!");
exit(1);
}
#ifdef X11
atoms_init ();
#endif
if (already_opened ()) {
g_printerr ("Another instance of xwinmosaic is opened.\n");
exit (1);
}
if (options.read_stdin) {
if(!options.format) {
options.show_icons = FALSE;
options.show_desktop = FALSE;
}
read_stdin ();
} else {
#ifdef X11
// Checks whether WM supports EWMH specifications.
if (!wm_supports_ewmh ()) {
GtkWidget *dialog = gtk_message_dialog_new
(NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Error: your WM does not support EWMH specifications.");
gtk_dialog_run (GTK_DIALOG (dialog));
g_signal_connect_swapped (dialog, "response",
G_CALLBACK (gtk_main_quit), NULL);
return 1;
}
active_window = (Window *) property (gdk_x11_get_default_root_xwindow (),
a_NET_ACTIVE_WINDOW,
XA_WINDOW,
NULL);
#endif
}
if (options.color_file)
read_colors ();
#ifdef WIN32
if (options.persistent) {
#ifdef DEBUG
g_printerr ("Installing Alt-Tab hook");
#endif
install_alt_tab_hook();
}
#endif
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "XWinMosaic");
GdkRectangle rect = current_monitor_size ();
width = rect.width;
height = rect.height;
if (options.at_pointer) {
gdk_display_get_pointer (gdk_display_get_default (), NULL, &options.center_x, &options.center_y, NULL);
gint monitors = gdk_screen_get_n_monitors (gdk_screen_get_default ());
if (monitors > 1) {
guint xm = 0, ym = 0;
gint current_monitor = gdk_screen_get_monitor_at_point (gdk_screen_get_default (),
options.center_x, options.center_y);
for (int i = 0; i < current_monitor; i++) {
GdkRectangle mon_rect;
gdk_screen_get_monitor_geometry (gdk_screen_get_default (), i, &mon_rect);
xm += mon_rect.width;
ym += mon_rect.height;
}
if (xm && ym) {
options.center_x %= xm;
options.center_y %= ym;
}
}
if (options.center_x < options.box_width/2)
options.center_x = options.box_width/2 + 1;
else if (options.center_x > width - options.box_width/2)
options.center_x = width - options.box_width/2 - 1;
if (options.center_y < options.box_height/2)
options.center_y = options.box_height/2 + 1;
else if (options.center_y > height - options.box_height/2)
options.center_y = height - options.box_height/2 - 1;
} else {
options.center_x = width/2;
options.center_y = height/2;
}
gtk_window_set_default_size (GTK_WINDOW (window), width, height);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_decorated (GTK_WINDOW (window), 0);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), 1);
gtk_window_set_skip_pager_hint (GTK_WINDOW (window), 1);
/**/
gtk_widget_add_events (GTK_WIDGET (window), GDK_FOCUS_CHANGE);
g_signal_connect (G_OBJECT (window), "focus-out-event",
G_CALLBACK (on_focus_change), NULL);
/**/
layout = gtk_layout_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), layout);
if (options.screenshot) {
gtk_window_fullscreen (GTK_WINDOW (window));
GdkPixbuf *screenshot;
GdkPixmap *background = NULL;
GtkStyle *style = NULL;
screenshot = get_screenshot ();
gdk_pixbuf_render_pixmap_and_mask (screenshot, &background, NULL, 0);
style = gtk_style_new ();
style->bg_pixmap [0] = background;
gtk_widget_set_style (window, style);
gtk_widget_set_style (layout, style);
}
search = mosaic_search_box_new ();
mosaic_box_set_font (MOSAIC_BOX (search), options.font);
gtk_widget_set_can_focus (search, FALSE);
GtkRequisition s_req;
gtk_widget_size_request (search, &s_req);
gtk_layout_put (GTK_LAYOUT (layout), search,
(width - s_req.width)/2, height - s_req.height - options.box_height);
g_signal_connect (G_OBJECT (search), "changed",
G_CALLBACK (refilter), NULL);
g_signal_connect (G_OBJECT (window), "key-press-event",
G_CALLBACK (on_key_press), NULL);
g_signal_connect_swapped(G_OBJECT (window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
if (!options.screenshot) {
window_shape_bitmap = (GdkDrawable *) gdk_pixmap_new (NULL, width, height, 1);
draw_mask (window_shape_bitmap, 0);
gtk_widget_shape_combine_mask (window, window_shape_bitmap, 0, 0);
}
gtk_widget_show_all (window);
gtk_widget_hide (search);
gtk_window_present (GTK_WINDOW (window));
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
if (options.persistent)
gtk_widget_hide (window);
GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
#ifdef X11
myown_window = GDK_WINDOW_XID (gdk_window);
if (!options.read_stdin) {
// Get PropertyNotify events from root window.
XSelectInput (gdk_x11_get_default_xdisplay (),
gdk_x11_get_default_root_xwindow (),
PropertyChangeMask);
gdk_window_add_filter (NULL, (GdkFilterFunc) event_filter, NULL);
}
#endif
#ifdef WIN32
myown_window = GDK_WINDOW_HWND (gdk_window);
#endif
update_box_list ();
draw_mosaic (GTK_LAYOUT (layout), boxes, wsize, 0,
options.box_width, options.box_height);
#ifdef X11
// Window will be shown on all desktops (and so hidden in windows list)
unsigned int desk = 0xFFFFFFFF; // -1
XChangeProperty(gdk_x11_get_default_xdisplay (), myown_window, a_NET_WM_DESKTOP, XA_CARDINAL,
32, PropModeReplace, (unsigned char *)&desk, 1);
#endif
gtk_main ();
#ifdef X11
if (!options.read_stdin)
XFree (wins);
#endif
return 0;
}
static void draw_mosaic (GtkLayout *where,
GtkWidget **widgets, int rsize,
int focus_on,
int rwidth, int rheight)
{
boxes_drawn = 0;
int cur_x = options.center_x - rwidth/2;
int cur_y = options.center_y - rheight/2;
if (rsize) {
int i = 0;
int offset = 0;
int max_offset = (width*2) / rwidth + (height*2) / rheight;
int side = 0;
while (i < rsize) {
int j = 0;
do {
if (i == rsize)
break;
if (cur_x >= 0 && cur_x+rwidth <= width && cur_y >= 0 && cur_y+rheight <= height) {
offset = 0;
if (gtk_widget_get_parent (widgets[i]))
gtk_layout_move (GTK_LAYOUT (where), widgets[i], cur_x, cur_y);
else
gtk_layout_put (GTK_LAYOUT (where), widgets[i], cur_x, cur_y);
gtk_widget_set_size_request (widgets[i], rwidth, rheight);
gtk_widget_show (widgets[i]);
if (!options.screenshot) {
box_rects[i].x = cur_x;
box_rects[i].y = cur_y;
boxes_drawn++;
}
i++;
} else {
offset++;
}
if (side) {
if (j % (side * 4) < side || j % (side * 4) >= side * 3)
cur_x += rwidth;
else
cur_x -= rwidth;
if (j % (side * 4) < side * 2)
cur_y += rheight;
else
cur_y -= rheight;
}
j++;
} while (j < side * 4);
if (offset >= max_offset)
break;
side++;
cur_x = options.center_x - rwidth/2;
cur_y -= rheight;
}
if (focus_on >= rsize)
// If some window was killed and focus was on the last element
focus_on = rsize-1;
gtk_widget_grab_focus (widgets[focus_on]);
}
if (!options.screenshot) {
draw_mask (window_shape_bitmap, rsize);
gtk_widget_shape_combine_mask (window, window_shape_bitmap, 0, 0);
}
}
