/** @pre display is valid, themes is valid, cursors is valid. @pre all widgets are zero'd. @pre themes is valid and has loaded at least a background for the popup_menu_parent. @post Menu with borders and background but no items is created but not mapped. @brief This function is used to create a blank and generic menu. Items must be added by caller. @return void **/ void create_popup_menu(Display *display, struct Popup_menu *menu, struct Themes *themes, struct Cursors *cursors) { XSetWindowAttributes set_attributes; Window root = DefaultRootWindow(display); Screen* screen = DefaultScreenOfDisplay(display); int black = BlackPixelOfScreen(screen); const int width = menu->inner_width + themes->popup_menu[popup_l_edge].w + themes->popup_menu[popup_r_edge].w; const int height = menu->inner_height + themes->popup_menu[popup_t_edge].h + themes->popup_menu[popup_b_edge].h; menu->widgets[popup_menu_parent].widget = XCreateSimpleWindow(display, root , 0, 0 , width, height, 0, black, black); XDefineCursor(display, menu->widgets[popup_menu_parent].widget, cursors->normal); XSetWindowBackgroundPixmap(display, menu->widgets[popup_menu_parent].widget , themes->popup_menu[popup_menu_parent].state_p[normal]); //Currently, this is the "base" of the popup menu. //A similar loop will be needed for the actual menu items but not in this function for(int i = popup_t_edge; i < popup_menu_parent; i++) { //popup_menu_parent already done int x = themes->popup_menu[i].x; int y = themes->popup_menu[i].y; int w = themes->popup_menu[i].w; int h = themes->popup_menu[i].h; if(x < 0) x += width; if(y < 0) y += height; if(w <= 0) w += width; if(h <= 0) h += height; menu->widgets[i].widget = XCreateSimpleWindow(display , menu->widgets[popup_menu_parent].widget , x, y, w, h, 0, black, black); if(themes->popup_menu[i].w <= 0) w = XWidthOfScreen(screen); if(themes->popup_menu[i].h <= 0) h = XWidthOfScreen(screen); for(int j = 0; j <= inactive; j++) { if(themes->popup_menu[i].state_p[j]) { menu->widgets[i].state[j] = XCreateSimpleWindow(display, menu->widgets[i].widget , 0, 0, w, h, 0, black, black); XSetWindowBackgroundPixmap(display, menu->widgets[i].state[j] , themes->popup_menu[i].state_p[j]); if(j == normal) XMapWindow(display, menu->widgets[i].state[j]); } } XMapWindow(display, menu->widgets[i].widget); } set_attributes.override_redirect = True; XChangeWindowAttributes(display, menu->widgets[popup_menu_parent].widget, CWOverrideRedirect, &set_attributes); // XMapWindow(display, menu->widgets[popup_menu_parent].widget); XFlush(display); }
void StartupId::update_startupid() { int yoffset = 0; if( blinking ) { XSetWindowBackgroundPixmap( QX11Info::display(), startup_window, pixmaps[ color_to_pixmap[ color_index ]].handle()); XClearWindow( QX11Info::display(), startup_window ); if( ++color_index >= ( sizeof( color_to_pixmap ) / sizeof( color_to_pixmap[ 0 ] ))) color_index = 0; } else if( bouncing ) { yoffset = frame_to_yoffset[ frame ]; QPixmap pixmap = pixmaps[ frame_to_pixmap[ frame ] ]; XSetWindowBackgroundPixmap( QX11Info::display(), startup_window, pixmap.handle()); XClearWindow( QX11Info::display(), startup_window ); if ( !pixmap.mask().isNull() ) // set mask XShapeCombineMask( QX11Info::display(), startup_window, ShapeBounding, 0, 0, pixmap.mask().handle(), ShapeSet ); else // clear mask XShapeCombineMask( QX11Info::display(), startup_window, ShapeBounding, 0, 0, None, ShapeSet ); if ( ++frame >= ( sizeof( frame_to_yoffset ) / sizeof( frame_to_yoffset[ 0 ] ) ) ) frame = 0; } Window dummy1, dummy2; int x, y; int dummy3, dummy4; unsigned int dummy5; if( !XQueryPointer( QX11Info::display(), QX11Info::appRootWindow(), &dummy1, &dummy2, &x, &y, &dummy3, &dummy4, &dummy5 )) { XUnmapWindow( QX11Info::display(), startup_window ); update_timer.start( 100 ); return; } QPoint c_pos( x, y ); int cursor_size = 0; #ifdef HAVE_XCURSOR cursor_size = XcursorGetDefaultSize( QX11Info::display()); #endif int X_DIFF; if( cursor_size <= 16 ) X_DIFF = 8 + 7; else if( cursor_size <= 32 ) X_DIFF = 16 + 7; else if( cursor_size <= 48 ) X_DIFF = 24 + 7; else X_DIFF = 32 + 7; int Y_DIFF = X_DIFF; XMoveWindow( QX11Info::display(), startup_window, c_pos.x() + X_DIFF, c_pos.y() + Y_DIFF + yoffset ); XMapWindow( QX11Info::display(), startup_window ); XRaiseWindow( QX11Info::display(), startup_window ); update_timer.start( bouncing ? 30 : 100 ); QApplication::flush(); }
void win_draw(win_t *win) { if (win == NULL || win->xwin == None) return; XSetWindowBackgroundPixmap(win->env.dpy, win->xwin, win->pm); XClearWindow(win->env.dpy, win->xwin); }
static gboolean cycle_window (GstXOverlay * ov) { XGCValues values; Window old_win = win; GC old_gc = gc; win = XCreateSimpleWindow (disp, root, 0, 0, width, height, 0, 0, 0); XSetWindowBackgroundPixmap (disp, win, None); gc = XCreateGC (disp, win, 0, &values); XMapRaised (disp, win); XSync (disp, FALSE); gst_x_overlay_set_xwindow_id (ov, win); if (old_win) { XDestroyWindow (disp, old_win); XFreeGC (disp, old_gc); XSync (disp, FALSE); } return TRUE; }
Bool CreateTrayWindow() { tray_init(dpy, &tray); XVisualInfo* vi = tray_get_visual(dpy, &tray); Window dock = tray_get_dock(dpy); if (vi && vi->visual) { Window p = DefaultRootWindow (dpy); Colormap colormap = XCreateColormap(dpy, p, vi->visual, AllocNone); XSetWindowAttributes wsa; wsa.background_pixmap = 0; wsa.colormap = colormap; wsa.background_pixel = 0; wsa.border_pixel = 0; tray.window = XCreateWindow(dpy, p, -1, -1, 1, 1, 0, vi->depth, InputOutput, vi->visual, CWBackPixmap|CWBackPixel|CWBorderPixel|CWColormap, &wsa); } else { tray.window = XCreateSimpleWindow (dpy, DefaultRootWindow(dpy), \ 0, 0, 1, 1, 0, \ BlackPixel (dpy, DefaultScreen (dpy)), \ WhitePixel (dpy, DefaultScreen (dpy))); XSetWindowBackgroundPixmap(dpy, tray.window, ParentRelative); } if (tray.window == (Window) NULL) return False; // GNOME, NET WM Specification tray_send_opcode(dpy, dock, CurrentTime, SYSTEM_TRAY_REQUEST_DOCK, 0, 0); XSizeHints size_hints; size_hints.flags = PWinGravity | PBaseSize; size_hints.base_width = 22; size_hints.base_height = 22; XSetWMNormalHints(dpy, tray.window, &size_hints); if (!ProcessTrayIcon(inactive_xpm, &tray.icon[INACTIVE_ICON], &tray.icon_mask[INACTIVE_ICON], &tray.picon[INACTIVE_ICON])) { fprintf(stderr, "failed to get inactive icon image\n"); return False; } if (!ProcessTrayIcon(active_xpm, &tray.icon[ACTIVE_ICON], &tray.icon_mask[ACTIVE_ICON], &tray.picon[ACTIVE_ICON])) { fprintf(stderr, "failed to get active icon image\n"); return False; } /* GCs for copy and drawing on mask */ XGCValues gv; gv.foreground = BlackPixel(dpy, DefaultScreen(dpy)); gv.background = BlackPixel(dpy, DefaultScreen(dpy)); tray.gc = XCreateGC(dpy, tray.window, GCBackground|GCForeground, &gv); XSetClipMask(dpy, tray.gc, tray.icon_mask[0]); XSelectInput (dpy, tray.window, ExposureMask | KeyPressMask | \ ButtonPressMask | ButtonReleaseMask | StructureNotifyMask \ | EnterWindowMask | PointerMotionMask | LeaveWindowMask | VisibilityChangeMask); return True; }
void xfwmWindowSetBG (xfwmWindow * win, xfwmPixmap * pix) { gboolean done; if ((win->width < 1) || (win->height < 1) || (pix->width < 1) || (pix->height < 1)) { return; } done = FALSE; #ifdef HAVE_RENDER if ((win->visual != win->screen_info->visual) || (win->depth != win->screen_info->depth)) { /* Try to use Render */ done = xfwmWindowCopyComposite (win, pix); } #endif if (!done) { /* Use the good old way */ XSetWindowBackgroundPixmap (myScreenGetXDisplay (win->screen_info), win->window, pix->pixmap); } }
void SetRootWindow(char *tline) { XWindowAttributes root_attr; XpmAttributes xpm_attributes; Pixmap shapeMask; int val; XGetWindowAttributes(dpy,root,&root_attr); xpm_attributes.colormap = root_attr.colormap; xpm_attributes.valuemask = XpmSize | XpmReturnPixels|XpmColormap; if((val = XpmReadFileToPixmap(dpy,root, tline, &rootXpm, &shapeMask, &xpm_attributes))!= XpmSuccess) { if(val == XpmOpenFailed) fprintf(stderr, "Couldn't open pixmap file\n"); else if(val == XpmColorFailed) fprintf(stderr, "Couldn't allocate required colors\n"); else if(val == XpmFileInvalid) fprintf(stderr, "Invalid Format for an Xpm File\n"); else if(val == XpmColorError) fprintf(stderr, "Invalid Color specified in Xpm FIle\n"); else if(val == XpmNoMemory) fprintf(stderr, "Insufficient Memory\n"); exit(1); } XSetWindowBackgroundPixmap(dpy, root, rootXpm); save_colors = 1; XClearWindow(dpy,root); }
static void create_host_window (void) { unsigned long valuemask; XSetWindowAttributes attributes; display = XOpenDisplay (NULL); if (display) { window = XCreateSimpleWindow (display, DefaultRootWindow (display), 0, 0, x_width, x_height, 0, 0, 0); if (window) { valuemask = CWOverrideRedirect; attributes.override_redirect = True; XChangeWindowAttributes (display, window, valuemask, &attributes); XSetWindowBackgroundPixmap (display, window, None); XMapRaised (display, window); XSync (display, FALSE); } else { GST_DEBUG ("could not create X window!"); } } else { GST_DEBUG ("could not open display!"); } }
g_error x11_create_window(hwrbitmap *hbmp) { struct x11bitmap *xb; g_error e; XSetWindowAttributes attr; e = g_malloc((void**)&xb, sizeof(struct x11bitmap)); errorcheck; memset(xb,0,sizeof(struct x11bitmap)); xb->is_window = 1; /* Create the window. * The size and everything else will be configured in x11_internal_window_resize() */ xb->d = XCreateSimpleWindow(x11_display, RootWindow(x11_display, x11_screen),0,0,1,1,0,0,0); xb->sb.w = xb->sb.h = 0; /* This prevents X from redrawing the window background at all */ XSetWindowBackgroundPixmap(x11_display, xb->d, None); /* Optionally double-buffer this window */ if (get_param_int("video-x11","doublebuffer",1)) { e = x11_new_backbuffer(&xb, xb); errorcheck; } xb->next_window = x11_window_list; x11_window_list = xb; *hbmp = (hwrbitmap) xb; return success; }
uint32_t createSurface(const IntSize& size) { XVisualInfo* visualInfo = glXGetVisualFromFBConfig(m_display, m_fbConfig); if (!visualInfo) return 0; Colormap cmap = XCreateColormap(m_display, m_offScreenWindow.getXWindow(), visualInfo->visual, AllocNone); XSetWindowAttributes a; a.background_pixel = WhitePixel(m_display, 0); a.border_pixel = BlackPixel(m_display, 0); a.colormap = cmap; m_surface = XCreateWindow(m_display, m_offScreenWindow.getXWindow(), 0, 0, size.width(), size.height(), 0, visualInfo->depth, InputOutput, visualInfo->visual, CWBackPixel | CWBorderPixel | CWColormap, &a); XSetWindowBackgroundPixmap(m_display, m_surface, 0); XCompositeRedirectWindow(m_display, m_surface, CompositeRedirectManual); m_glxSurface = glXCreateWindow(m_display, m_fbConfig, m_surface, 0); XFree(visualInfo); // Make sure the XRender Extension is available. int eventBasep, errorBasep; if (!XRenderQueryExtension(m_display, &eventBasep, &errorBasep)) return 0; XMapWindow(m_display, m_surface); return m_surface; }
void clientwin_move(ClientWin *cw, float f, int x, int y) { /* int border = MAX(1, (double)DISTANCE(cw->mainwin) * f * 0.25); */ int border = 0; XSetWindowBorderWidth(cw->mainwin->dpy, cw->mini.window, border); cw->factor = f; cw->mini.x = x + (int)cw->x * f; cw->mini.y = y + (int)cw->y * f; if(cw->mainwin->lazy_trans) { cw->mini.x += cw->mainwin->x; cw->mini.y += cw->mainwin->y; } cw->mini.width = MAX(1, (int)cw->client.width * f); cw->mini.height = MAX(1, (int)cw->client.height * f); XMoveResizeWindow(cw->mainwin->dpy, cw->mini.window, cw->mini.x - border, cw->mini.y - border, cw->mini.width, cw->mini.height); if(cw->pixmap) XFreePixmap(cw->mainwin->dpy, cw->pixmap); if(cw->destination) XRenderFreePicture(cw->mainwin->dpy, cw->destination); cw->pixmap = XCreatePixmap(cw->mainwin->dpy, cw->mini.window, cw->mini.width, cw->mini.height, cw->mainwin->depth); XSetWindowBackgroundPixmap(cw->mainwin->dpy, cw->mini.window, cw->pixmap); cw->destination = XRenderCreatePicture(cw->mainwin->dpy, cw->pixmap, cw->mini.format, 0, 0); }
static void update_bg() { if (currootpmap != *rootpmap && *rootpmap != 0) { currootpmap = *rootpmap; imlib_context_set_drawable(currootpmap); if (bg) { imlib_context_set_image(bg); imlib_free_image(); } bg = imlib_create_image_from_drawable(0, bbx, bby, bbwidth, bbheight, 1); Pixmap tile, mask; imlib_context_set_display(bbdpy); imlib_context_set_visual(bbvis); imlib_context_set_drawable(bbwin); imlib_context_set_image(bg); Imlib_Image tmpbg = imlib_clone_image(); tile_image_blend(tmpbg, theme->tile_img, 0, bbwidth); imlib_render_pixmaps_for_whole_image(&tile, &mask); XSetWindowBackgroundPixmap(bbdpy, bbwin, tile); imlib_free_pixmap_and_mask(tile); imlib_free_image(); } }
void Rterm_sync_screen(struct R_termscreen *screen, int row, int column, int len, int mode) { if (screen == NULL) { return; } if (screen->buf) { if (mode == RTERM_SCREEN_SYNC) { XSetWindowBackgroundPixmap(screen->window->app->display, screen->window->id, screen->buf); XClearWindow(screen->window->app->display, screen->window->id); XSync(screen->window->app->display, False); } else { XCopyArea(screen->window->app->display, screen->buf, screen->window->id, screen->bufgc, Rterm_screen_column_x(screen, column), Rterm_screen_row_y(screen, row), screen->charw * len, screen->charh, Rterm_screen_column_x(screen, column), Rterm_screen_row_y(screen, row)); } } return; }
void App::setBackground(const string& themedir) { string filename; filename = themedir + "/background.png"; Image *image = new Image; bool loaded = image->Read(filename.c_str()); if (!loaded){ // try jpeg if png failed filename = ""; filename = themedir + "/background.jpg"; loaded = image->Read(filename.c_str()); } if (loaded) { string bgstyle = cfg.getOption("background_style"); if (bgstyle == "stretch") { image->Resize(XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), XHeightOfScreen(ScreenOfDisplay(Dpy, Scr))); } else if (bgstyle == "tile") { image->Tile(XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), XHeightOfScreen(ScreenOfDisplay(Dpy, Scr))); } else if (bgstyle == "center") { string hexvalue = cfg.getOption("background_color"); hexvalue = hexvalue.substr(1,6); image->Center(XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)), hexvalue.c_str()); } else { // plain color or error string hexvalue = cfg.getOption("background_color"); hexvalue = hexvalue.substr(1,6); image->Center(XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)), hexvalue.c_str()); } Pixmap p = image->createPixmap(Dpy, Scr, Root); XSetWindowBackgroundPixmap(Dpy, Root, p); } XClearWindow(Dpy, Root); XFlush(Dpy); }
void win_draw(win_t *win) { if (!win || !win->xwin) return; XSetWindowBackgroundPixmap(win->env.dpy, win->xwin, win->pm); XClearWindow(win->env.dpy, win->xwin); }
void mbdesktop_progress_dialog_set_percentage (MBDesktop *mb, int percentage) { int barwidth = ((mb->desktop_width/2) * percentage) / 100 ; XSetForeground(mbdesktop_xdisplay(mb), mb->gc, WhitePixel(mbdesktop_xdisplay(mb), mbdesktop_xscreen(mb))); /* Clear Background */ XFillRectangle(mbdesktop_xdisplay(mb), mb->win_dialog_backing, mb->gc, 0, 0, mb->win_dialog_w, mb->win_dialog_h); XSetForeground(mbdesktop_xdisplay(mb), mb->gc, mb_col_xpixel(mb->hl_col)); XFillRectangle(mbdesktop_xdisplay(mb), mb->win_dialog_backing, mb->gc, DIALOG_BORDER, DIALOG_BORDER, barwidth, (mb->desktop_height/4)); XSetWindowBackgroundPixmap(mbdesktop_xdisplay(mb), mb->win_dialog, mb->win_dialog_backing); XClearWindow(mbdesktop_xdisplay(mb), mb->win_dialog); XFlush(mbdesktop_xdisplay(mb)); }
void KWD::Switcher::redrawPixmap () { QPainter p (&mPixmap); QPainter bp (&mBackgroundPixmap); const int contentWidth = mPixmap.width (); const int contentHeight = mPixmap.height (); mPixmap.fill (Qt::transparent); p.setCompositionMode (QPainter::CompositionMode_Source); p.setRenderHint (QPainter::SmoothPixmapTransform); mBackground->resizeFrame (QSizeF (contentWidth, contentHeight)); mBackground->paintFrame (&p, QRect (0, 0, contentWidth, contentHeight)); bp.setCompositionMode (QPainter::CompositionMode_Source); bp.drawPixmap (0, 0, mPixmap, mBorder.left, mBorder.top, mGeometry.width (), mGeometry.height ()); XSetWindowBackgroundPixmap (QX11Info::display (), mId, mX11BackgroundPixmap); XClearWindow (QX11Info::display (), mId); }
winlist_t * gui_new_win(void) { winlist_t *win; if (free_win) { win = free_win; free_win = free_win->next; bzero(win, sizeof(winlist_t)); } else { win = oxim_malloc(sizeof(winlist_t), True); } win->window = XCreateSimpleWindow(gui->display, gui->root, 0, 0, 1, 1, 1, 0, 0); XSetWindowBackgroundPixmap(gui->display, win->window, ParentRelative); win->win_draw_func = NULL; win->win_event_func = NULL; win->next = winlist; winlist = win; return win; }
EAPI void ecore_x_window_pixmap_set(Ecore_X_Window win, Ecore_X_Pixmap pmap) { LOGFN(__FILE__, __LINE__, __FUNCTION__); XSetWindowBackgroundPixmap(_ecore_x_disp, win, pmap); }
void clientwin_unmap(ClientWin *cw) { if(cw->damage) { XDamageDestroy(cw->mainwin->dpy, cw->damage); cw->damage = None; } if(cw->destination) { XRenderFreePicture(cw->mainwin->dpy, cw->destination); cw->destination = None; } if(cw->pixmap) { XFreePixmap(cw->mainwin->dpy, cw->pixmap); cw->pixmap = None; } XUnmapWindow(cw->mainwin->dpy, cw->mini.window); XSetWindowBackgroundPixmap(cw->mainwin->dpy, cw->mini.window, None); cw->focused = 0; }
int toolwin_win_create(ToolWin *tw) { tw->win = XCreateSimpleWindow(dpy, root, 20, 20, tw->w, tw->h, 0, 0, 0); tw->buf = XCreatePixmap(dpy, root, tw->w, tw->h, DefaultDepth(dpy,scr)); cairo_surface_t *t = cairo_xlib_surface_create(dpy, tw->buf, DefaultVisual(dpy,scr), tw->w, tw->h); tw->ctx = cairo_create(t); cairo_surface_destroy(t); cairo_set_font_face(tw->ctx,conf.font); cairo_set_font_size(tw->ctx,conf.font_size); XSelectInput(dpy, tw->win, EVENT_MASK); XSetTransientForHint(dpy, tw->win, win); XSetWMProtocols(dpy, tw->win, &WM_DELETE_WINDOW, 1); XSizeHints *hints = XAllocSizeHints(); hints->min_width = hints->max_width = tw->w; hints->min_height = hints->max_height = tw->h; hints->flags = PMinSize | PMaxSize; XSetWMNormalHints(dpy, tw->win, hints); XFree(hints); XStoreName(dpy, tw->win, tw->name); if (tw->backing) tw->backing(tw); else toolwin_backing(tw); XSetWindowBackgroundPixmap(dpy, tw->win, tw->buf); XFlush(dpy); return 0; }
void expose(XEvent *ev) { XExposeEvent *e = &ev->xexpose; if (e->window == info->win) info->draw(info); else { XSetWindowBackgroundPixmap(dpy, win, buf); XClearWindow(dpy,win); } }
static void showText(WScreen *scr, int x, int y, int h, int w, const char *text) { int width; int height; Pixmap pixmap; Pixmap mask; WMFont *font = scr->info_text_font; int side = 0; int ty; int bx, by; if (scr->balloon->contents) XFreePixmap(dpy, scr->balloon->contents); width = getMaxStringWidth(font, text) + 16; height = countLines(text) * WMFontHeight(font) + 4; if (height < 16) height = 16; if (width < height) width = height; if (x + width > scr->scr_width) { side = RIGHT; bx = x - width + w / 2; if (bx < 0) bx = 0; } else { side = LEFT; bx = x + w / 2; } if (bx + width > scr->scr_width) bx = scr->scr_width - width; if (y - (height + SPACE) < 0) { side |= TOP; by = y + h - 1; ty = SPACE; } else { side |= BOTTOM; by = y - (height + SPACE); ty = 0; } pixmap = makePixmap(scr, width, height, side, &mask); drawMultiLineString(scr->wmscreen, pixmap, scr->black, font, 8, ty + 2, text, strlen(text)); XSetWindowBackgroundPixmap(dpy, scr->balloon->window, pixmap); scr->balloon->contents = pixmap; XResizeWindow(dpy, scr->balloon->window, width, height + SPACE); XShapeCombineMask(dpy, scr->balloon->window, ShapeBounding, 0, 0, mask, ShapeSet); XFreePixmap(dpy, mask); XMoveWindow(dpy, scr->balloon->window, bx, by); XMapRaised(dpy, scr->balloon->window); scr->balloon->mapped = 1; }
void dockapp_set_background(Pixmap pixmap) { if (dockapp_iswindowed) { Pixmap bg; bg = create_bg_pixmap(); XCopyArea(display, pixmap, bg, gc, 0, 0, width, height, offset_w, offset_w); XSetWindowBackgroundPixmap(display, icon_window, bg); XSetWindowBackgroundPixmap(display, window, bg); XFreePixmap(display, bg); } else { XSetWindowBackgroundPixmap(display, icon_window, pixmap); XSetWindowBackgroundPixmap(display, window, pixmap); } XClearWindow(display, icon_window); XFlush(display); }
void win_draw(win_t *win) { if (win->bar.h > 0) win_draw_bar(win); XSetWindowBackgroundPixmap(win->env.dpy, win->xwin, win->buf.pm); XClearWindow(win->env.dpy, win->xwin); XFlush(win->env.dpy); }
/* **************************************************************** * Desenha o fundo da janela * **************************************************************** */ int draw_window (Display *dpy, Window win, XImage *ximage, IMAGE *ip) { char title[256]; static int old_width, old_height; /* * Pequena consistência. */ if (ximage->depth != DefaultDepth (dpy, screen)) { msg ( "\"%s\": imagem tem profundidade incorreta (%d :: %d)", ip->i_name, ximage->depth, DefaultDepth (dpy, screen) ); return (-1); } /* * Modifica o fundo, o tamanho e o título da janela. */ XSetWindowBackgroundPixmap (dpy, win, None); if (old_width == ximage->width && old_height == ximage->height) XResizeWindow (dpy, win, ximage->width - 1, ximage->height - 1); if (set_background (dpy, win, ximage, ip->i_name) < 0) return (-1); XResizeWindow (dpy, win, old_width = ximage->width, old_height = ximage->height); if (ip->i_comment == NOSTR) { snprintf ( title, sizeof (title), ip->i_ncolors > 0 ? "%s (%d x %d, %d cores)" : "%s (%d x %d)", basename (ip->i_name), ximage->width, ximage->height, ip->i_ncolors ); } else { snprintf ( title, sizeof (title), ip->i_ncolors > 0 ? "%s (%d x %d, %d cores), %s" : "%s (%d x %d)", basename (ip->i_name), ximage->width, ximage->height, ip->i_ncolors, ip->i_comment ); } XStoreName (dpy, win, title); XFlush (dpy); return (0); } /* end draw_window */
void InitTrayWindow(TrayWindow *trayWindow) { FcitxClassicUI *classicui = trayWindow->owner; Display *dpy = classicui->dpy; int iScreen = classicui->iScreen; char strWindowName[] = "Fcitx Tray Window"; if (!classicui->bUseTrayIcon || classicui->isSuspend) return; InitTray(dpy, trayWindow); XVisualInfo* vi = TrayGetVisual(dpy, trayWindow); if (vi && vi->visual) { Window p = DefaultRootWindow(dpy); Colormap colormap = XCreateColormap(dpy, p, vi->visual, AllocNone); XSetWindowAttributes wsa; wsa.background_pixmap = 0; wsa.colormap = colormap; wsa.background_pixel = 0; wsa.border_pixel = 0; trayWindow->window = XCreateWindow(dpy, p, -1, -1, 1, 1, 0, vi->depth, InputOutput, vi->visual, CWBackPixmap | CWBackPixel | CWBorderPixel | CWColormap, &wsa); } else { trayWindow->window = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy), -1, -1, 1, 1, 0, BlackPixel(dpy, DefaultScreen(dpy)), WhitePixel(dpy, DefaultScreen(dpy))); XSetWindowBackgroundPixmap(dpy, trayWindow->window, ParentRelative); } if (trayWindow->window == (Window) NULL) return; XSizeHints size_hints; size_hints.flags = PWinGravity | PBaseSize; size_hints.base_width = trayWindow->size; size_hints.base_height = trayWindow->size; XSetWMNormalHints(dpy, trayWindow->window, &size_hints); if (vi && vi->visual) trayWindow->cs_x = cairo_xlib_surface_create(dpy, trayWindow->window, trayWindow->visual.visual, 200, 200); else { Visual *target_visual = DefaultVisual(dpy, iScreen); trayWindow->cs_x = cairo_xlib_surface_create(dpy, trayWindow->window, target_visual, 200, 200); } trayWindow->cs = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 200, 200); XSelectInput(dpy, trayWindow->window, ExposureMask | KeyPressMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask | EnterWindowMask | PointerMotionMask | LeaveWindowMask | VisibilityChangeMask); ClassicUISetWindowProperty(classicui, trayWindow->window, FCITX_WINDOW_DOCK, strWindowName); TrayFindDock(dpy, trayWindow); }
RazorDeskManager::RazorDeskManager(const QString & configId, RazorSettings * config) : DesktopPlugin(configId, config) { m_launchMode = DesktopPlugin::launchModeFromString(config->value("icon-launch-mode").toString()); config->beginGroup(configId); bool makeIcons = config->value("icons", false).toBool(); //now we got the desktop we need to determine if the user wants a defined picture there QString finalPixmap = config->value("wallpaper", "").toString(); config->endGroup(); if (finalPixmap.isEmpty() || !QFile::exists(finalPixmap)) { //now we want to use the system default - we still need to find that one out though finalPixmap = razorTheme.desktopBackground(); qDebug() << "trying to get system-defaults" << finalPixmap; } if (! finalPixmap.isEmpty()) { qDebug() << "Creating wallpaper"; int width,height; QDesktopWidget * dw = QApplication::desktop(); if (dw->screenCount() == 1) { width=dw->width(); height = dw->height(); } else { width=dw->screenGeometry(-1).width(); height=dw->screenGeometry(-1).height(); } QPixmap pixmap(finalPixmap); pixmap = pixmap.scaled(width,height); Pixmap p = pixmap.handle(); XGrabServer(QX11Info::display()); XChangeProperty(QX11Info::display(), QX11Info::appRootWindow(), XfitMan::atom("_XROOTPMAP_ID"), XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &p, 1); XChangeProperty(QX11Info::display(), QX11Info::appRootWindow(), XfitMan::atom("ESETROOT_PMAP_ID"), XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &p, 1); XSetCloseDownMode(QX11Info::display(), RetainPermanent); XSetWindowBackgroundPixmap(QX11Info::display(), QX11Info::appRootWindow(), p); XClearWindow(QX11Info::display(), QX11Info::appRootWindow()); XUngrabServer(QX11Info::display()); XFlush(QX11Info::display()); } if (makeIcons) { deskicons = new RazorSettings("deskicons", this); m_fsw = new QFileSystemWatcher(QStringList() << QDesktopServices::storageLocation(QDesktopServices::DesktopLocation), this); connect(m_fsw, SIGNAL(directoryChanged(const QString&)), this, SLOT(updateIconList())); updateIconList(); } }
void window::set_background ( color& c ) { // hold a ref to the alloc'ed color back_color.set ( c ); XSetWindowBackgroundPixmap( env, hwnd, None ); /*XSetWindowBackground ( env, hwnd, c.pixel() ); */ refresh(); }
void feh_menu_redraw(feh_menu * m) { Imlib_Updates u, uu; if ((!m->needs_redraw) || (!m->visible) || (!m->updates)) return; m->needs_redraw = 0; if (!m->pmap) m->pmap = XCreatePixmap(disp, m->win, m->w, m->h, depth); XSetWindowBackgroundPixmap(disp, m->win, m->pmap); u = imlib_updates_merge_for_rendering(m->updates, m->w, m->h); m->updates = NULL; if (u) { D(("I have updates to render\n")); for (uu = u; u; u = imlib_updates_get_next(u)) { int x, y, w, h; Imlib_Image im; imlib_updates_get_coordinates(u, &x, &y, &w, &h); D(("update coords %d,%d %d*%d\n", x, y, w, h)); im = imlib_create_image(w, h); gib_imlib_image_fill_rectangle(im, 0, 0, w, h, 0, 0, 0, 0); if (im) { feh_menu_draw_to_buf(m, im, x, y); gib_imlib_render_image_on_drawable(m->pmap, im, x, y, 1, 0, 0); gib_imlib_free_image(im); XClearArea(disp, m->win, x, y, w, h, False); } } imlib_updates_free(uu); } return; }