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); } }