void win_set_sizehints(win_t *win) { XSizeHints sizehints; if (!win || !win->xwin) return; sizehints.flags = PMinSize | PMaxSize; sizehints.min_width = win->w; sizehints.max_width = win->w; sizehints.min_height = win->h; sizehints.max_height = win->h; XSetWMNormalHints(win->env.dpy, win->xwin, &sizehints); }
void OsWindow::set_resizable(bool resizable) { XSizeHints hints; hints.flags = PMinSize | PMaxSize; hints.min_width = resizable ? 1 : m_width; hints.min_height = resizable ? 1 : m_height; hints.max_width = resizable ? 65535 : m_width; hints.max_height = resizable ? 65535 : m_height; XSetWMNormalHints(m_x11_display, m_x11_window, &hints); m_resizable = resizable; }
void set_panel_window_geometry(Panel *panel) { update_strut(panel); // Fixed position and non-resizable window // Allow panel move and resize when tint2 reload config file int minwidth = panel_autohide ? panel->hidden_width : panel->area.width; int minheight = panel_autohide ? panel->hidden_height : panel->area.height; XSizeHints size_hints; size_hints.flags = PPosition | PMinSize | PMaxSize; size_hints.min_width = minwidth; size_hints.max_width = panel->area.width; size_hints.min_height = minheight; size_hints.max_height = panel->area.height; XSetWMNormalHints(server.display, panel->main_win, &size_hints); if (!panel->is_hidden) { if (panel_horizontal) { XMoveResizeWindow(server.display, panel->main_win, panel->posx, panel->posy, panel->area.width, panel->area.height); } else { XMoveResizeWindow(server.display, panel->main_win, panel->posx, panel->posy, panel->area.width, panel->area.height); } } else { int diff = (panel_horizontal ? panel->area.height : panel->area.width) - panel_autohide_height; if (panel_horizontal) { XMoveResizeWindow(server.display, panel->main_win, panel->posx, panel->posy + diff, panel->hidden_width, panel->hidden_height); } else { XMoveResizeWindow(server.display, panel->main_win, panel->posx + diff, panel->posy, panel->hidden_width, panel->hidden_height); } } }
void gTrayIcon::setVisible(bool vl) { if (vl) { if (!plug) { _loopLevel = gApplication::loopLevel() + 1; plug = gtk_status_icon_new(); updatePicture(); updateTooltip(); #ifdef GDK_WINDOWING_X11 // Needed, otherwise the icon does not appear in Gnome or XFCE notification area! XSizeHints hints; hints.flags = PMinSize; hints.min_width = _iconw; hints.min_height = _iconh; XSetWMNormalHints(gdk_x11_display_get_xdisplay(gdk_display_get_default()), gtk_status_icon_get_x11_window_id(plug), &hints); #endif gtk_status_icon_set_visible(plug, TRUE); //g_signal_connect(G_OBJECT(plug), "destroy", G_CALLBACK(cb_destroy),(gpointer)this); g_signal_connect(G_OBJECT(plug), "button-press-event", G_CALLBACK(cb_button_press), (gpointer)this); g_signal_connect(G_OBJECT(plug), "button-release-event", G_CALLBACK(cb_button_release),(gpointer)this); //g_signal_connect(G_OBJECT(plug), "activate", G_CALLBACK(cb_activate),(gpointer)this); //g_signal_connect(G_OBJECT(plug),"focus-in-event",G_CALLBACK(tray_focus_In),(gpointer)this); //g_signal_connect(G_OBJECT(plug),"focus-out-event",G_CALLBACK(tray_focus_Out),(gpointer)this); //g_signal_connect(G_OBJECT(plug),"enter-notify-event",G_CALLBACK(tray_enterleave),(gpointer)this); //g_signal_connect(G_OBJECT(plug),"leave-notify-event",G_CALLBACK(tray_enterleave),(gpointer)this); g_signal_connect(G_OBJECT(plug), "popup-menu", G_CALLBACK(cb_menu), (gpointer)this); g_signal_connect(G_OBJECT(plug), "scroll-event", G_CALLBACK(cb_scroll), (gpointer)this); //g_signal_connect(G_OBJECT(plug),"expose-event", G_CALLBACK(cb_expose), (gpointer)this); _visible_count++; usleep(10000); // BUG: Embedding too fast sometimes fails with GTK+ } } else { if (plug) { GB.Post((void (*)())hide_icon, (intptr_t)plug); plug = NULL; _visible_count--; } } }
void resizeWindow(Window window, int w, int h) { // Tell the window manager to respect the requested size XSizeHints size_hints; size_hints.max_width = size_hints.min_width = w; size_hints.max_height = size_hints.min_height = h; size_hints.flags = PMinSize | PMaxSize; XSetWMNormalHints(display, window, &size_hints); XResizeWindow(display, window, w, h); waitForEvent(window, ConfigureNotify); }
void match_size_hints(Window xterm, int add_y) { XSizeHints * size_hints = XAllocSizeHints(); long returned = 0; XGetWMNormalHints(gdi.display, xterm, size_hints, &returned); size_hints->base_height += add_y; size_hints->max_height += add_y; size_hints->min_height += add_y; size_hints->width_inc = 1; size_hints->height_inc = 1; XSetWMNormalHints(gdi.display, gdi.mainw, size_hints); XFree(size_hints); }
void resize(int w, int h) { if (w == width && h == height) { return; } eglWaitClient(); // We need to ensure that pending events are processed here, and XSync // with discard = True guarantees that, but it appears the limited // event processing we do so far is sufficient //XSync(display, True); Drawable::resize(w, h); XResizeWindow(display, window, w, h); // Tell the window manager to respect the requested size XSizeHints size_hints; size_hints.max_width = size_hints.min_width = w; size_hints.max_height = size_hints.min_height = h; size_hints.flags = PMinSize | PMaxSize; XSetWMNormalHints(display, window, &size_hints); waitForEvent(ConfigureNotify); eglWaitNative(EGL_CORE_NATIVE_ENGINE); /* * Some implementations won't update the backbuffer unless we recreate * the EGL surface. */ int eglWidth; int eglHeight; eglQuerySurface(eglDisplay, surface, EGL_WIDTH, &eglWidth); eglQuerySurface(eglDisplay, surface, EGL_HEIGHT, &eglHeight); if (eglWidth != width || eglHeight != height) { recreate(); eglQuerySurface(eglDisplay, surface, EGL_WIDTH, &eglWidth); eglQuerySurface(eglDisplay, surface, EGL_HEIGHT, &eglHeight); } assert(eglWidth == width); assert(eglHeight == height); }
/** * @brief Replace the size hints for the WM_NORMAL_HINTS property of a window. * * @param win pointer to a ws window structure */ static void wsWindowSizeHint(wsWindow *win) { XSizeHints size; size.flags = 0; /* obsolete, solely for compatibility reasons */ size.flags |= PPosition; size.x = win->X; size.y = win->Y; /* obsolete, solely for compatibility reasons */ size.flags |= PSize; size.width = win->Width; size.height = win->Height; /* a minimum of 4 is said to avoid off-by-one errors and be required by mga_vid */ size.flags |= PMinSize; size.min_width = 4; size.min_height = 4; if (win->Property & wsMinSize) { size.min_width = win->Width; size.min_height = win->Height; } if (win->Property & wsMaxSize) { size.flags |= PMaxSize; size.max_width = win->Width; size.max_height = win->Height; } if (vo_keepaspect && (win->Property & wsAspect)) { size.flags |= PAspect; size.min_aspect.x = win->Width; size.min_aspect.y = win->Height; size.max_aspect.x = win->Width; size.max_aspect.y = win->Height; } size.flags |= PBaseSize; size.base_width = 0; size.base_height = 0; size.flags |= PWinGravity; size.win_gravity = StaticGravity; XSetWMNormalHints(wsDisplay, win->WindowID, &size); }
void xf_ResizeDesktopWindow(xfInfo* xfi, xfWindow* window, int width, int height) { XSizeHints* size_hints; size_hints = XAllocSizeHints(); if (size_hints) { size_hints->flags = PMinSize | PMaxSize; size_hints->min_width = size_hints->max_width = xfi->width; size_hints->min_height = size_hints->max_height = xfi->height; XSetWMNormalHints(xfi->display, window->handle, size_hints); XFree(size_hints); } }
void Gflushlazyq (void) { if (Glazyq.flag & LAZYMANAGE) { XtManageChildren (Glazyq.mws, Glazyq.mwn); Glazyq.flag &= ~LAZYMANAGE; } if (Glazyq.flag & LAZYREALIZE) { XtRealizeWidget (Glazyq.rw); if (Glazyq.flag & LAZYRHINTS) XSetWMNormalHints (Gdisplay, XtWindow (Glazyq.rw), &Glazyq.hints); XSetWMProtocols (Gdisplay, XtWindow (Glazyq.rw), &Gwmdelatom, 1); XtOverrideTranslations (Glazyq.rw, Gwmdeltable); Glazyq.flag &= ~LAZYRHINTS; Glazyq.flag &= ~LAZYREALIZE; } }
int mlx_int_anti_resize_win(t_xvar *xvar,Window win,int w,int h) { XSizeHints hints; long toto; XGetWMNormalHints(xvar->display,win,&hints,&toto); hints.width = w; hints.height = h; hints.min_width = w; hints.min_height = h; hints.max_width = w; hints.max_height = h; hints.flags = PPosition | PSize | PMinSize | PMaxSize; XSetWMNormalHints(xvar->display,win,&hints); }
void OS_X11::set_window_resizable(bool p_enabled) { XSizeHints *xsh; xsh = XAllocSizeHints(); xsh->flags = p_enabled ? 0L : PMinSize | PMaxSize; if(!p_enabled) { XWindowAttributes xwa; XGetWindowAttributes(x11_display,x11_window,&xwa); xsh->min_width = xwa.width; xsh->max_width = xwa.width; xsh->min_height = xwa.height; xsh->max_height = xwa.height; } XSetWMNormalHints(x11_display, x11_window, xsh); XFree(xsh); current_videomode.resizable = p_enabled; }
void setSizeHint(Display* display, Window window, int minWidth, int minHeight, int maxWidth, int maxHeight) { XSizeHints hints = {}; if(minWidth > 0 && minHeight > 0) hints.flags |= PMinSize; if(maxWidth > 0 && maxHeight > 0) hints.flags |= PMaxSize; hints.min_width = minWidth; hints.min_height = minHeight; hints.max_width = maxWidth; hints.max_height = maxHeight; XSetWMNormalHints(display, window, &hints); }
void Glazyrealize (Widget w, int hintsflag, XSizeHints *hintsp) { if (Glazyq.flag & LAZYREALIZE) { XtRealizeWidget (Glazyq.rw); if (Glazyq.flag & LAZYRHINTS) XSetWMNormalHints (Gdisplay, XtWindow (Glazyq.rw), &Glazyq.hints); XSetWMProtocols (Gdisplay, XtWindow (Glazyq.rw), &Gwmdelatom, 1); XtOverrideTranslations (Glazyq.rw, Gwmdeltable); } else Glazyq.flag |= LAZYREALIZE; Glazyq.rw = w; if (hintsflag) { Glazyq.flag |= LAZYRHINTS; Glazyq.hints = *hintsp; } else Glazyq.flag &= ~LAZYRHINTS; }
void _al_xwin_reset_size_hints(ALLEGRO_DISPLAY *d) { ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (void *)d; XSizeHints *hints = XAllocSizeHints(); hints->flags = PMinSize | PMaxSize; hints->min_width = 0; hints->min_height = 0; // FIXME: Is there a way to remove/reset max dimensions? hints->max_width = 32768; hints->max_height = 32768; XSetWMNormalHints(system->x11display, glx->window, hints); XFree(hints); }
void XSetWMProperties(Display * display, Window w, XTextProperty * window_name, XTextProperty * icon_name, char **argv, int argc, XSizeHints * normal_hints, XWMHints * wm_hints, XClassHint *class_hints) { if (window_name) XSetWMName(display, w, window_name); if (icon_name) XSetWMIconName(display, w, icon_name); if (normal_hints) XSetWMNormalHints(display, w, normal_hints); if (wm_hints) XSetWMHints(display, w, wm_hints); if (class_hints) XSetWMClassHints(display, w, class_hints); }
static void child_win_init(void) { XSetWindowAttributes attr; XGCValues gcv; XColor color, dummy; XSizeHints sizehints; /* * start graphical output */ if (!(display = XOpenDisplay(NULL))) { fprintf(stderr, "X: Unable to open X display\n"); exit(1); } XSetErrorHandler(x_error_handler); XAllocNamedColor(display, DefaultColormap(display, 0), "red", &color, &dummy); col_zeroline = color.pixel; col_background = WhitePixel(display, 0); col_trace = BlackPixel(display, 0); attr.background_pixel = col_background; window = XCreateWindow(display, XRootWindow(display, 0), 200, 200, WIDTH, HEIGHT, 5, DefaultDepth(display, 0), InputOutput, DefaultVisual(display, 0), CWBackPixel, &attr); if (!(pixmap = XCreatePixmap(display, window, WIDTH, HEIGHT, DefaultDepth(display, 0)))) { fprintf(stderr, "X: unable to open offscreen pixmap\n"); exit(1); } XSelectInput(display, window, KeyPressMask | StructureNotifyMask | ExposureMask) ; gcv.line_width = 1; gcv.line_style = LineSolid; gc = XCreateGC(display, pixmap, GCForeground | GCLineWidth, &gcv); /* * Do not allow the window to be resized */ memset(&sizehints, 0, sizeof(sizehints)); sizehints.min_width = sizehints.max_width = WIDTH; sizehints.min_height = sizehints.max_height = HEIGHT; sizehints.flags = PMinSize | PMaxSize; XSetWMNormalHints(display, window, &sizehints); XMapWindow(display, window); XSynchronize(display, 1); }
void set_dialog_properties (Display *d, Window w, char *name, int width, int height) { XTextProperty nameprop; if (!XStringListToTextProperty (&name, 1, &nameprop)) { warn ("XStringListToTextProperty failed\n"); return; } XSetWMName (d, w, &nameprop); XSizeHints *sh = XAllocSizeHints (); sh->base_width = sh->min_width = sh->max_width = width; sh->base_height = sh->min_height = sh->max_height = height; sh->flags = PBaseSize | PMinSize | PMaxSize; XSetWMNormalHints (d, w, sh); XFree (sh); }
// ---------------------------------------------------------------------------------------------- // Move window to x, y. // ---------------------------------------------------------------------------------------------- void wsMoveWindow(wsTWindow *win, int b, int x, int y) { if (b) { switch (x) { case -1: win->X = (wsMaxX / 2) - (win->Width / 2) + wsOrgX; break; case -2: win->X = wsMaxX - win->Width + wsOrgX; break; default: win->X = x; break; } switch (y) { case -1: win->Y = (wsMaxY / 2) - (win->Height / 2) + wsOrgY; break; case -2: win->Y = wsMaxY - win->Height + wsOrgY; break; default: win->Y = y; break; } } else { win->X = x; win->Y = y; } win->SizeHint.flags = PPosition | PWinGravity; win->SizeHint.x = win->X; win->SizeHint.y = win->Y; win->SizeHint.win_gravity = StaticGravity; XSetWMNormalHints(wsDisplay, win->WindowID, &win->SizeHint); XMoveWindow(wsDisplay, win->WindowID, win->X, win->Y); if (win->ReSize) win->ReSize(win->X, win->Y, win->Width, win->Height); }
void X11Window::set_maximum_size(int width, int height, bool size_is_client_area) { maximum_size = Size(width,height); if (!size_is_client_area) { maximum_size.width -= frame_extents.left + frame_extents.right; maximum_size.height -= frame_extents.top + frame_extents.bottom; } long user_hints; XGetWMNormalHints(handle.display, handle.window, size_hints, &user_hints); size_hints->max_width = maximum_size.width; size_hints->max_height = maximum_size.height; size_hints->flags |= PMaxSize; XSetWMNormalHints(handle.display, handle.window, size_hints); }
void QXlibWindow::doSizeHints() { Q_ASSERT(widget()->testAttribute(Qt::WA_WState_Created)); XSizeHints s; s.flags = 0; QRect g = geometry(); s.x = g.x(); s.y = g.y(); s.width = g.width(); s.height = g.height(); s.flags |= USPosition; s.flags |= PPosition; s.flags |= USSize; s.flags |= PSize; s.flags |= PWinGravity; s.win_gravity = QApplication::isRightToLeft() ? NorthEastGravity : NorthWestGravity; XSetWMNormalHints(mScreen->display()->nativeDisplay(), x_window, &s); }
void PropagateSizeHints(QWidget *w) { const auto display = QX11Info::display(); XSizeHints *sh = XAllocSizeHints(); sh->flags = PPosition | PSize | PMinSize | PMaxSize | PResizeInc; sh->x = w->x(); sh->y = w->y(); sh->min_width = w->minimumWidth(); sh->min_height = w->minimumHeight(); sh->base_width = w->baseSize().width(); sh->base_height = w->baseSize().height(); sh->max_width = w->maximumWidth(); sh->max_height = w->maximumHeight(); sh->width_inc = w->sizeIncrement().width(); sh->height_inc = w->sizeIncrement().height(); XSetWMNormalHints(display, w->winId(), sh); XFree(sh); }
void x_window_rep::set_size_limits (SI min_w, SI min_h, SI max_w, SI max_h) { if (min_w == Min_w && min_h == Min_h && max_w == Max_w && max_h == Max_h) return; Min_w= min_w; Min_h= min_h; Max_w= max_w; Max_h= max_h; min_w= min_w/PIXEL; min_h= min_h/PIXEL; max_w= max_w/PIXEL; max_h= max_h/PIXEL; XSizeHints* size_hints; ASSERT (size_hints= XAllocSizeHints (), "out of memory (X server)"); size_hints->flags = PMinSize | PMaxSize; size_hints->min_width = min_w; size_hints->min_height = min_h; size_hints->max_width = max_w; size_hints->max_height = max_h; XSetWMNormalHints (dpy, win, size_hints); XFree(size_hints); }
void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height) { int mode = 0, rate, sizeChanged = GL_FALSE; XSizeHints* sizehints; rate = window->refreshRate; if (window->mode == GLFW_FULLSCREEN) { // Get the closest matching video mode for the specified window size mode = _glfwGetClosestVideoMode(&width, &height, &rate); } if (!window->resizable) { // Update window size restrictions to match new window size sizehints = XAllocSizeHints(); sizehints->flags = 0; sizehints->min_width = sizehints->max_width = width; sizehints->min_height = sizehints->max_height = height; XSetWMNormalHints(_glfwLibrary.X11.display, window->X11.handle, sizehints); XFree(sizehints); } // Change window size before changing fullscreen mode? if (window->mode == GLFW_FULLSCREEN && (width > window->width)) { XResizeWindow(_glfwLibrary.X11.display, window->X11.handle, width, height); sizeChanged = GL_TRUE; } if (window->mode == GLFW_FULLSCREEN) { // Change video mode, keeping current refresh rate _glfwSetVideoModeMODE(mode, window->refreshRate); } // Set window size (if not already changed) if (!sizeChanged) XResizeWindow(_glfwLibrary.X11.display, window->X11.handle, width, height); }
bool XPlatformWindow::tell_platform_size_hints() { if ( _min_w == -1) return true; // hack for don't care // tell window manager that we'd like our own size and position XSizeHints* size_hints; if ((size_hints = XAllocSizeHints()) == NULL) { warning("X structure allocation for size hints failed--spy won't work."); close(); return false; } size_hints->flags = PPosition | PSize | PMinSize | PMaxSize; size_hints->min_width = _min_w; size_hints->max_width = _max_w; size_hints->min_height = _min_h; size_hints->max_height = _max_h; XSetWMNormalHints(_display, _xwindow, size_hints); return true; }
void win_update_sizehints(win_t *win) { if (win == NULL || win->xwin == None) return; if ((win->sizehints.flags & USSize) != 0) { win->sizehints.width = win->w; win->sizehints.height = win->h + win->bar.h; } if ((win->sizehints.flags & USPosition) != 0) { win->sizehints.x = win->x; win->sizehints.y = win->y; } if (options->fixed_win) { win->sizehints.min_width = win->sizehints.max_width = win->w; win->sizehints.min_height = win->sizehints.max_height = win->h + win->bar.h; } XSetWMNormalHints(win->env.dpy, win->xwin, &win->sizehints); }
// ---------------------------------------------------------------------------------------------- // Move window to x, y. // ---------------------------------------------------------------------------------------------- void wsMoveWindow(wsTWindow *win, Bool abs, int x, int y) { if (abs) { win->X = x; win->Y = y; } else wsWindowPosition(win, x, y, win->Width, win->Height); win->SizeHint.flags = PPosition | PWinGravity; win->SizeHint.x = win->X; win->SizeHint.y = win->Y; win->SizeHint.win_gravity = StaticGravity; XSetWMNormalHints(wsDisplay, win->WindowID, &win->SizeHint); XMoveWindow(wsDisplay, win->WindowID, win->X, win->Y); if (win->ReSize) win->ReSize(win->X, win->Y, win->Width, win->Height); }
void X11Window::_impl_setSize(int32 width, int32 height) { if (m_Desc.resizable) { // Update window size restrictions to match new window size XSizeHints* hints = XAllocSizeHints(); hints->flags |= (PMinSize | PMaxSize); hints->min_width = hints->max_width = width; hints->min_height = hints->max_height = height; XSetWMNormalHints(m_Display, m_Window, hints); XFree(hints); } XResizeWindow(m_Display, m_Window, width, height); XFlush(m_Display); }
void TopWindow::SyncSizeHints() { GuiLock __; Size min = GetMinSize(); Size max = GetMaxSize(); if(!sizeable) min = max = GetRect().Size(); Window w = GetWindow(); if(w && (min != xminsize || max != xmaxsize) && !frameless) { xminsize = min; xmaxsize = max; size_hints->min_width = min.cx; size_hints->min_height = min.cy; size_hints->max_width = max.cx; size_hints->max_height = max.cy; size_hints->flags = PMinSize|PMaxSize; XSetWMNormalHints(Xdisplay, w, size_hints); } }
void TextEdit::createWindow() { if (GWindow::m_Display == 0) { if (!GWindow::initX()) { perror("A connection with X server could not be established"); exit(1); } } // Load font, calculate window size, etc. initialize(); strncpy(m_WindowTitle, getFileName(), 127); setBgColorName("LightGray"); setFgColorName("black"); GWindow::createWindow(); // Save background and foreground colors bgColor = getBackground(); fgColor = getForeground(); // Status line colors /usr/X11R6/lib/X11/rgb.txt bgStatusLineColor = allocateColor("MidnightBlue"); fgStatusLineColor = allocateColor("white"); setFont(textFont); // Hints for window manager XSizeHints sizeHints; memset(&sizeHints, 0, sizeof(sizeHints)); // Minimal size 16 * 1 sizeHints.min_width = 44*dx + leftMargin + rightMargin; sizeHints.min_height = 1*dy + topMargin + bottomMargin; // Base size sizeHints.base_width = 0*dx + leftMargin + rightMargin; sizeHints.base_height = 0*dy + topMargin + bottomMargin; // Resize increment sizeHints.width_inc = dx; sizeHints.height_inc = dy; sizeHints.flags = (PMinSize | PBaseSize | PResizeInc); XSetWMNormalHints(m_Display, m_Window, &sizeHints); }