int
a_lower(char * opt[]) {
(void)opt;
XLowerWindow(dzen.dpy, dzen.title_win.win);
if(dzen.slave_win.max_lines)
XLowerWindow(dzen.dpy, dzen.slave_win.win);
return 0;
}
void
xfwmWindowTemp (ScreenInfo *screen_info, Visual *visual,
gint depth, Window parent,
xfwmWindow * win,
int x, int y, int width, int height,
long eventmask,
gboolean bottom)
{
XSetWindowAttributes attributes;
attributes.event_mask = eventmask;
attributes.override_redirect = TRUE;
win->window = XCreateWindow (myScreenGetXDisplay (screen_info),
parent, x, y, width, height, 0, 0,
InputOnly, CopyFromParent,
CWEventMask | CWOverrideRedirect,
&attributes);
if (bottom)
{
XLowerWindow (myScreenGetXDisplay (screen_info), win->window);
}
else
{
XRaiseWindow (myScreenGetXDisplay (screen_info), win->window);
}
XMapWindow (myScreenGetXDisplay (screen_info), win->window);
win->map = TRUE;
win->screen_info = screen_info;
win->x = x;
win->y = y;
win->width = width;
win->height = height;
xfwmWindowSetVisual (win, visual, depth);
}
void show_window(GtkButton *button, gpointer data)
{
int i;
char *name;
unsigned long len;
Window *windows;
Atom atom;
XWindowAttributes attr;
XEvent xev;
XFetchName(disp, (Window) data, &name);
windows = (Window*) get_windows(&len);
g_print ("Raising: [%s]\n", name);
for (i = 0; i < (int) len; i++) {
if ((Window) data != windows[i]) {
XLowerWindow(disp, windows[i]);
}
}
XRaiseWindow(disp, (Window) data);
XFlush(disp);
XSync(disp, False);
}
void DrawWinBorder(UltimateContext *uc)
{
int active;
unsigned long winbg;
if(uc->frame == None) return;
if((active = (uc == FocusWin))) {
uc->flags |= ACTIVE_BORDER;
} else {
uc->flags &= ~ACTIVE_BORDER;
}
winbg = active ? TheScreen.ActiveBorder[TheScreen.desktop.ActiveWorkSpace]
: TheScreen.InactiveBorder[TheScreen.desktop.ActiveWorkSpace];
XSetWindowBackground(disp, uc->border, winbg);
XClearWindow(disp, uc->border);
if(uc->title.win != None) {
XSetWindowBackground(disp, uc->title.win, winbg);
if(uc->title.name && (InitS.BorderTitleFlags
& (active ? BT_ACTIVE_TITLE : BT_INACTIVE_TITLE))){
XRaiseWindow(disp,uc->title.win);
DrawTitle(uc);
} else {
XLowerWindow(disp, uc->title.win);
if(uc->flags & SHAPED) DrawTitle(uc);
}
}
DrawFrameBevel(uc);
}
bool CL_OpenGLWindowProvider_GLX::on_clicked(XButtonEvent &event)
{
if (event.button != 1) // Left mouse button
return true;
int height = get_viewport().get_height();
glDrawBuffer(GL_BACK);
glReadBuffer(GL_FRONT);
CL_Rect rect = CL_Rect(event.x,event.y, CL_Size(1,1));
CL_PixelBuffer pixelbuffer(rect.get_width(), rect.get_height(), cl_rgba8);
glReadPixels(
rect.left, height - rect.bottom,
rect.right - rect.left, rect.bottom - rect.top,
GL_RGBA,
GL_UNSIGNED_INT_8_8_8_8,
pixelbuffer.get_data());
const cl_ubyte32 *xptr = (const cl_ubyte32 *) (pixelbuffer.get_data());
if (((*xptr) & 0xFF) < 10)
{
XLowerWindow(x11_window.get_display(), x11_window.get_window());
return false;
}
return true;
}
void XImlib2Caption::lowerWindow()
{
XDesktopContainer * xContainer =
dynamic_cast<XDesktopContainer *>(AbstractImage::container);
XLowerWindow( xContainer->getDisplay(), window );
}
void
initGraphics( int argc, char *argv[] )
{
XSetWindowAttributes myWindowAttributes;
int myDepth;
XGCValues myGCValues;
unsigned long myWindowMask;
myDisplay = XOpenDisplay( "" );
if (myDisplay == NULL)
{
exit (0);
}
myScreen = DefaultScreen (myDisplay);
myDepth = DefaultDepth (myDisplay, myScreen);
if ( parseArgs( argc, argv ) )
assignDefault();
myWindowAttributes.border_pixel =
BlackPixel (myDisplay, myScreen);
myWindowAttributes.background_pixel =
getColor( myDisplay, 252, 234, 212 );
myWindowAttributes.override_redirect = 0;
myWindowMask = CWBackPixel | CWBorderPixel | CWOverrideRedirect;
myWindow = XCreateWindow (myDisplay,
RootWindow (myDisplay, myScreen),
window_x,
window_y,
window_width, window_height,
BORDER_WIDTH, myDepth, InputOutput,
CopyFromParent, myWindowMask,
&myWindowAttributes);
myGC = XCreateGC (myDisplay, myWindow, (unsigned long) 0, &myGCValues);
if (myGC == 0)
{
XDestroyWindow(myDisplay, myScreen);
exit (0);
}
myFont = XLoadQueryFont (myDisplay, "9x15");
if (myFont == (XFontStruct *)NULL)
{
fprintf(stderr,"Cannot get font:9x15.\n");
myFont = NULL;
}
else
XSetFont (myDisplay, myGC, myFont->fid);
XSetForeground (myDisplay, myGC, BlackPixel( myDisplay, myScreen ) );
XMapWindow (myDisplay, myWindow);
XLowerWindow( myDisplay, myWindow );
paint();
XFlush( myDisplay );
}
static void hide(struct vidisp_st *st)
{
if (!st)
return;
if (st->win)
XLowerWindow(st->disp, st->win);
}
/*
* Request that Infowin be lowered
*/
static errr Infowin_lower(void)
{
/* Lower towards invisibility */
XLowerWindow(Metadpy->dpy, Infowin->win);
/* Success */
return (0);
}
void
restack(void) {
Client *c;
XEvent ev;
if(!sel)
return;
else
XLowerWindow(dpy, sel->win);
for(c = getnext(clients); c; c = getnext(c->next)) {
if(c == sel)
continue;
XLowerWindow(dpy, c->win);
}
XSync(dpy, False);
while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
}
/*
* Class: XlibWrapper
* Method: XLowerWindow
* Signature: (JJ)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_XLowerWindow
(JNIEnv *env, jclass clazz, jlong display, jlong window)
{
AWT_CHECK_HAVE_LOCK();
XLowerWindow( (Display *)display,(Window) window);
}
/***********************************************************************
*
* Procedure:
* list_lower - displays packet contents to stderr
*
***********************************************************************/
void list_lower(unsigned long *body)
{
PagerWindow *t;
Window target_w;
target_w = body[0];
t = Start;
while((t!= NULL)&&(t->w != target_w))
{
t = t->next;
}
if(t!= NULL)
{
if(t->PagerView != None)
XLowerWindow(dpy,t->PagerView);
if (HilightDesks && (t->desk - desk1>=0) && (t->desk - desk1<ndesks))
XLowerWindow(dpy,Desks[t->desk - desk1].CPagerWin);
XLowerWindow(dpy,t->IconView);
}
}
static void do_map(client_t *c, int do_raise)
{
if (IS_ON_CUR_DESK(c)) {
XMapWindow(dpy, c->win);
if (do_raise) {
XMapRaised(dpy, c->frame);
} else {
XLowerWindow(dpy, c->frame);
XMapWindow(dpy, c->frame);
}
}
}
int iupdrvBaseSetZorderAttrib(Ihandle* ih, const char* value)
{
if (iupdrvIsVisible(ih))
{
if (iupStrEqualNoCase(value, "TOP"))
XRaiseWindow(iupmot_display, XtWindow(ih->handle));
else
XLowerWindow(iupmot_display, XtWindow(ih->handle));
}
return 0;
}
void event_button_press(XEvent* e) {
Panel* panel = get_panel(e->xany.window);
if (!panel) return;
if (wm_menu && !tinto_handles_click(panel, &e->xbutton)) {
forward_click(e);
return;
}
point_T point = {e->xbutton.x, e->xbutton.y};
task_drag = click_task(panel, point);
if (panel_layer == BOTTOM_LAYER) XLowerWindow(server.dsp, panel->main_win);
}
int iupdrvBaseSetZorderAttrib(Ihandle* ih, const char* value)
{
if (iupdrvIsVisible(ih))
{
Widget widget = (Widget)iupAttribGet(ih, "_IUP_EXTRAPARENT");
if (iupStrEqualNoCase(value, "TOP"))
XRaiseWindow(iupmot_display, XtWindow(widget));
else
XLowerWindow(iupmot_display, XtWindow(widget));
}
return 0;
}
void x11_window_set_flags(hwrbitmap window, int flags) {
struct x11bitmap *xb = XB(window)->frontbuffer ? XB(window)->frontbuffer : XB(window);
XSetWindowAttributes attr;
xb->window_flags = flags;
/* If this is an unmanaged window or the background,
* use OverrideRedirect to keep the window manager from messing with it.
*/
attr.override_redirect = (flags & (PG_WINDOW_UNMANAGED | PG_WINDOW_BACKGROUND)) != 0;
XChangeWindowAttributes(x11_display, xb->d, CWOverrideRedirect, &attr);
/* Background windows sit below everything else and take the whole screen */
if (flags & PG_WINDOW_BACKGROUND) {
XLowerWindow(x11_display, xb->d);
VID(window_set_size)(dts->top->display,vid->lxres,vid->lyres);
}
}
/*
* Lowers the current window (by Z order change)
*/
void FGAPIENTRY glutPushWindow( void )
{
freeglut_assert_ready;
freeglut_assert_window;
#if TARGET_HOST_UNIX_X11
XLowerWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
SetWindowPos(
fgStructure.Window->Window.Handle,
HWND_BOTTOM,
0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE
);
#endif
}
/*
* Lowers the current window (by Z order change)
*/
void FGAPIENTRY glutPushWindow( void )
{
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPushWindow" );
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPushWindow" );
#if TARGET_HOST_UNIX_X11
XLowerWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle );
#elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
SetWindowPos(
fgStructure.CurrentWindow->Window.Handle,
HWND_BOTTOM,
0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE
);
#endif
}
void wxTopLevelWindowMotif::Lower()
{
Widget top = (Widget) GetTopWidget();
Window parent_window = XtWindow( top ),
next_parent = XtWindow( top ),
root = RootWindowOfScreen( XtScreen( top ) );
// search for the parent that is child of ROOT, because the WM may
// reparent twice and notify only the next parent (like FVWM)
while( next_parent != root )
{
Window *theChildren;
unsigned int n;
parent_window = next_parent;
XQueryTree( XtDisplay( top ), parent_window, &root,
&next_parent, &theChildren, &n );
XFree( theChildren ); // not needed
}
XLowerWindow( XtDisplay( top ), parent_window );
}
static DWORD
DrvStackingOrder(LPARAM dwParm1, LPARAM dwParm2, LPVOID lpStruct)
{
HWND hWndInsertAfter = (HWND)dwParm1;
HWND WinAfter = (HWND)dwParm2;
Window win = (Window)lpStruct;
Window win_restack[2];
PRIVATEDISPLAY *Disp = GETDP();
int nFunc = (int)hWndInsertAfter;
switch (nFunc) {
case (int)HWND_TOP:
#ifdef LATER
/* this should be resolved at the upper level */
#else
case (int)HWND_TOPMOST:
#endif
XRaiseWindow(Disp->display, win);
break;
case (int)HWND_BOTTOM:
#ifdef LATER
/* this should be resolved at the upper level */
#else
case (int)HWND_NOTOPMOST:
#endif
XLowerWindow(Disp->display, win);
break;
default:
/* this means a real hWndInsertAfter */
win_restack[0] = WinAfter;
win_restack[1] = win;
XRestackWindows(Disp->display, win_restack, 2);
break;
}
return 1L;
}
void MMSFB::realignLayer() {
#ifdef __HAVE_XLIB__
static bool first = true;
if(first==false)
return;
first=false;
for(int i=0; ;i++) {
if(mmsfb->x_windows[i]==0)
break;
else if(mmsfb->x_windows[i]!=mmsfb->input_window) {
XLockDisplay(mmsfb->x_display);
XLowerWindow(mmsfb->x_display, mmsfb->x_windows[i]);
XFlush(mmsfb->x_display);
XSync(mmsfb->x_display,False);
X11_IMPL *impl = (X11_IMPL *)mmsfb->layer[i]->getImplementation();
XPutImage(mmsfb->x_display, mmsfb->x_windows[i], impl->x_gc, mmsfb->rootimage, 0,0, 0, 0, mmsfb->display_w,
mmsfb->display_h);
//XUnmapWindow(mmsfb->x_display, mmsfb->x_windows[i]);
//printf("unmapping layer %d\n", i);
XSync(mmsfb->x_display,False);
XMapWindow(mmsfb->x_display, mmsfb->x_windows[i]);
XRaiseWindow(mmsfb->x_display, mmsfb->input_window);
//printf("mapping layer %d\n", i);
XFlush(mmsfb->x_display);
XSync(mmsfb->x_display,False);
XUnlockDisplay(mmsfb->x_display);
}
}
#endif
}
void X11Window::show() const
{
// Map the window
if( m_type == GenericWindow::VoutWindow )
{
XLowerWindow( XDISPLAY, m_wnd );
XMapWindow( XDISPLAY, m_wnd );
}
else if( m_type == GenericWindow::FullscreenWindow )
{
XMapRaised( XDISPLAY, m_wnd );
setFullscreen();
toggleOnTop( true );
}
else if( m_type == GenericWindow::FscWindow )
{
XMapRaised( XDISPLAY, m_wnd );
toggleOnTop( true );
}
else
{
XMapRaised( XDISPLAY, m_wnd );
}
}
void XLibWrapper::sendWindowToBack( Window window )
{
XLowerWindow( _display, window );
}
bool qapp::x11EventFilter(XEvent *event)
{
xwindow *client;
Window w;
XEvent ev;
XConfigureRequestEvent *cev;
XClientMessageEvent *mev;
XCrossingEvent *xev;
XCirculateRequestEvent *rev;
XPropertyEvent *pev;
#ifdef DEBUGMSG
#include "eventnames.h"
if(event->type < 36)
logmsg << "Received: " << event_names[event->type] << " (WId:" << event->xany.window << ")\n";
#endif
while(waitpid(-1, NULL, WNOHANG) > 0);
if(sighup)
{
wm_restart();
tb_mn->readmenu();
read_cprops();
sighup = FALSE;
}
switch(event->type)
{
case DestroyNotify:
w = event->xdestroywindow.window;
if((client = cwindows.find(w)) != NULL)
{
clients.remove(client);
if(smode && client->isstate())
keyboard::tscreen(); // turn off screen mode
tb_pg->draw_pager();
return TRUE;
}
if(tb_ap->remove(w)) // client on toolbar
return TRUE;
if(event->xdestroywindow.event != w)
return TRUE;
if(w == tb->winId() || w == tb_pg->winId() || w == tb_wl->winId() || w == tb_mn->winId() || w == tb_pb->winId())
sig_term(SIGTERM);
return FALSE;
case MapNotify:
if(event->xmap.event != event->xmap.window)
return TRUE;
if((client = pwindows.find(event->xmap.window)) != NULL)
tb_pg->add(client); // add to pager
return FALSE;
case UnmapNotify:
if((client = cwindows.find(event->xunmap.window)) != NULL)
{
if(event->xunmap.send_event)
{
// client requested transitions
// normal -> withdrawn
// iconic -> withdrawn
client->withdraw();
}
else
client->unmap();
return TRUE;
}
if(event->xunmap.event != event->xunmap.window)
return TRUE;
if(pwindows.find(event->xunmap.window) != NULL)
tb_pg->draw_pager();
return FALSE;
case EnterNotify:
xev = &event->xcrossing;
if(event->xcrossing.window == qt_xrootwin())
{
stopautofocus();
rootptr = TRUE;
}
else if(mrb == FALSE && menu_open == FALSE && (client = (xwindow *)widgetAt(xev->x_root, xev->y_root)) != NULL &&
clients.find(client) != -1 && ((client = clients.current()) != focusclient || rootptr))
{
rootptr = FALSE;
setinactive(client); // old client to inactive, save new client
if(xev->detail != NotifyInferior)
client->startautofocus();
client->setchildfocus(xev->time);
client->setcmapfocus();
}
return FALSE;
case ColormapNotify:
if((client = cwindows.find(event->xcolormap.window)) != NULL)
{
client->setcmap(event->xcolormap.colormap);
return TRUE;
}
return FALSE;
case PropertyNotify:
pev = &event->xproperty;
if((client = cwindows.find(pev->window)) != NULL)
{
if(pev->atom == XA_WM_NORMAL_HINTS)
{
client->get_wmnormalhints();
}
else if(pev->atom == XA_WM_HINTS)
{
client->get_wmhints();
}
else if(pev->atom == XA_WM_NAME || pev->atom == XA_WM_ICON_NAME)
{
client->get_wmname();
}
else if(pev->atom == wm_colormaps)
{
client->get_colormaps();
if(client == focusclient)
client->setcmapfocus();
}
return TRUE;
}
return FALSE;
case ConfigureNotify:
if(event->xconfigure.event != event->xconfigure.window)
return TRUE;
if((client = pwindows.find(event->xconfigure.window)) != NULL)
{
tb_pg->draw_pager();
while(XCheckTypedEvent(qt_xdisplay(), ConfigureNotify, &ev));
}
return TRUE;
case ReparentNotify:
if((client = cwindows.find(event->xreparent.window)) != NULL &&
event->xreparent.parent != client->winId())
{
clients.remove(client);
tb_pg->draw_pager();
}
return TRUE;
case ButtonPress:
w = event->xbutton.window;
if(w == qt_xrootwin()) // set focus to root window
XSetInputFocus(qt_xdisplay(), w, RevertToPointerRoot, CurrentTime);
if(w == tb->winId() || w == tb_pb->winId() || w == tb_ap->winId())
XRaiseWindow(qt_xdisplay(), tb->winId());
if(w == qt_xrootwin() || w == tb_pg->winId())
install_colormap(None);
return FALSE;
case FocusOut:
if(menu_open) // Qt 2.2.4 does not seem to like this if a menu is open
return TRUE;
return FALSE;
case ClientMessage:
mev = &event->xclient;
if(mev->message_type == wm_change_state && mev->format == 32 &&
mev->data.l[0] == IconicState && (client = cwindows.find(mev->window)) != NULL)
client->iconify();
return TRUE;
case CirculateRequest:
rev = &event->xcirculaterequest;
if(rev->place == PlaceOnTop)
XRaiseWindow(qt_xdisplay(), rev->window);
else
XLowerWindow(qt_xdisplay(), rev->window);
return TRUE;
case ConfigureRequest:
cev = &event->xconfigurerequest;
XWindowChanges wc;
if((client = cwindows.find(cev->window)) != NULL)
{
#ifdef DEBUGMSG
logmsg << "configure request to client (WId:" << client->winId() << ")\n";
#endif
if(cev->value_mask & (CWWidth|CWHeight|CWX|CWY))
{
if(smode && client->isstate())
keyboard::tscreen();
if(! client->is_tiled() || client == tmaxclient)
{
int cx,cy,cw,ch;
if(cev->value_mask & CWWidth)
cw = cev->width;
else
cw = client->width();
if(cev->value_mask & CWHeight)
ch = cev->height;
else
ch = client->getcheight();
if((cev->value_mask & CWX) && ! client->is_tiled())
cx = cev->x;
else
cx = client->x();
if((cev->value_mask & CWY) && ! client->is_tiled())
cy = cev->y;
else
cy = client->y();
client->resize_request(cx, cy, cw, ch);
}
cev->value_mask &= ~(CWWidth|CWHeight|CWX|CWY);
}
if(! cev->value_mask)
return TRUE;
wc.width = client->width();
wc.height = client->height();
wc.x = client->x();
wc.y = client->y();
wc.border_width = 0;
wc.sibling = cev->above;
wc.stack_mode = cev->detail;
XConfigureWindow(qt_xdisplay(), client->winId(), cev->value_mask, &wc);
send_configurenotify(client);
}
else // never mapped window
{
if(cev->window == tb->winId() || tb_ap->client_exists(cev->window)) // deny requests on toolbar
return TRUE;
#ifdef DEBUGMSG
logmsg << "configure request to unreparented window (WId:" << cev->window << ")\n";
#endif
wc.x = cev->x;
wc.y = cev->y;
wc.width = cev->width;
wc.height = cev->height;
cev->value_mask &= (CWX|CWY|CWWidth|CWHeight);
XConfigureWindow(qt_xdisplay(), cev->window, cev->value_mask, &wc);
}
return TRUE;
case MapRequest:
run_client(event->xmaprequest.window);
return TRUE;
case KeyPress:
return(keyboard::keypress(&event->xkey));
default:
if(servershapes && event->type == (ShapeEventBase + ShapeNotify))
{
XShapeEvent *sev = (XShapeEvent *)event;
if((client = cwindows.find(sev->window)) != NULL)
{
client->reshape();
return TRUE;
}
}
}
return FALSE;
}
void KWM::lower(Window w){
XLowerWindow(qt_xdisplay(), w);
}
static void
event_process (XEvent *ev)
{
MdmWindow *gw;
Window w;
XWindowChanges wchanges;
trap_push ();
switch (ev->type) {
case MapRequest:
w = ev->xmaprequest.window;
gw = find_window (w, FALSE);
if (gw == NULL) {
if (ev->xmaprequest.parent == wm_root) {
XGrabServer (wm_disp);
gw = add_window (w,
TRUE /* center */,
FALSE /* is_mapped */);
XUngrabServer (wm_disp);
}
}
XMapWindow (wm_disp, w);
break;
case ConfigureRequest:
XGrabServer (wm_disp);
w = ev->xconfigurerequest.window;
gw = find_window (w, FALSE);
wchanges.border_width = ev->xconfigurerequest.border_width;
wchanges.sibling = ev->xconfigurerequest.above;
wchanges.stack_mode = ev->xconfigurerequest.detail;
if (gw == NULL ||
gw->deco == None) {
wchanges.x = ev->xconfigurerequest.x;
wchanges.y = ev->xconfigurerequest.y;
} else {
wchanges.x = 1;
wchanges.y = 1;
}
wchanges.width = ev->xconfigurerequest.width;
wchanges.height = ev->xconfigurerequest.height;
XConfigureWindow (wm_disp,
w,
ev->xconfigurerequest.value_mask,
&wchanges);
if (gw != NULL) {
gw->x = ev->xconfigurerequest.x;
gw->y = ev->xconfigurerequest.y;
if (gw->deco != None) {
wchanges.x = ev->xconfigurerequest.x - 1;
wchanges.y = ev->xconfigurerequest.y - 1;
wchanges.width = ev->xconfigurerequest.width + 2
+ 2*ev->xconfigurerequest.border_width;;
wchanges.height = ev->xconfigurerequest.height + 2
+ 2*ev->xconfigurerequest.border_width;;
wchanges.border_width = 0;
XConfigureWindow (wm_disp,
gw->deco,
ev->xconfigurerequest.value_mask,
&wchanges);
center_x_window (gw, gw->deco, gw->win);
} else {
center_x_window (gw, gw->win, gw->win);
}
shadow_follow (gw);
}
XUngrabServer (wm_disp);
break;
case CirculateRequest:
w = ev->xcirculaterequest.window;
gw = find_window (w, FALSE);
if (gw == NULL) {
if (ev->xcirculaterequest.place == PlaceOnTop)
XRaiseWindow (wm_disp, w);
else
XLowerWindow (wm_disp, w);
} else {
if (ev->xcirculaterequest.place == PlaceOnTop) {
if (gw->shadow != None)
XRaiseWindow (wm_disp, gw->shadow);
if (gw->deco != None)
XRaiseWindow (wm_disp, gw->deco);
else
XRaiseWindow (wm_disp, gw->win);
} else {
if (gw->deco != None)
XLowerWindow (wm_disp, gw->deco);
else
XLowerWindow (wm_disp, gw->win);
if (gw->shadow != None)
XLowerWindow (wm_disp, gw->shadow);
}
}
break;
case MapNotify:
w = ev->xmap.window;
gw = find_window (w, FALSE);
if (gw != NULL) {
if (gw->ignore_next_map > 0) {
gw->ignore_next_map --;
break;
}
if ( ! ev->xmap.override_redirect &&
focus_new_windows) {
mdm_wm_focus_window (w);
}
}
break;
case UnmapNotify:
w = ev->xunmap.window;
gw = find_window (w, FALSE);
if (gw != NULL) {
if (gw->ignore_next_unmap > 0) {
gw->ignore_next_unmap --;
break;
}
XGrabServer (wm_disp);
if (gw->deco != None)
XUnmapWindow (wm_disp, gw->deco);
if (gw->shadow != None)
XUnmapWindow (wm_disp, gw->shadow);
reparent_to_root (gw);
remove_window (w);
XDeleteProperty (wm_disp, w, XA_WM_STATE);
if (w != wm_login_window)
revert_focus_to_login ();
XUngrabServer (wm_disp);
}
break;
case DestroyNotify:
w = ev->xdestroywindow.window;
gw = find_window (w, FALSE);
if (gw != NULL) {
XGrabServer (wm_disp);
remove_window (w);
if (w != wm_login_window)
revert_focus_to_login ();
XUngrabServer (wm_disp);
}
break;
case EnterNotify:
w = ev->xcrossing.window;
gw = find_window (w, TRUE);
if (gw != NULL)
mdm_wm_focus_window (gw->win);
break;
case PropertyNotify:
if (ev->xproperty.atom == XA_NET_WM_STRUT)
{
mdm_wm_update_struts (ev->xproperty.display,
ev->xproperty.window);
constrain_all_windows ();
}
break;
default:
break;
}
trap_pop ();
}
void
panel_start_gui(panel *p)
{
ENTER;
//gtk_rc_parse_string(transparent_rc);
p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0);
gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE);
gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "trayer");
gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel");
gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_CENTER);
g_signal_connect ( G_OBJECT(p->topgwin) , "delete-event" , G_CALLBACK(panel_delete_event) , p);
g_signal_connect ( G_OBJECT(p->topgwin) , "destroy-event", G_CALLBACK(panel_destroy_event), p);
g_signal_connect ( G_OBJECT (p->topgwin), "size-request" , G_CALLBACK(panel_size_req) , p);
g_signal_connect ( G_OBJECT (p->topgwin), "size-allocate", G_CALLBACK(panel_size_alloc), p);
if (p->transparent) {
g_signal_connect (G_OBJECT (p->topgwin), "configure-event", G_CALLBACK(panel_configure_event), p);
g_signal_connect (G_OBJECT (p->topgwin), "style-set", G_CALLBACK( panel_style_set), p);
}
if (p->on_primary) {
GdkDisplay *display = gdk_display_get_default ();
GdkScreen *screen = gdk_display_get_screen(display, 0);
g_signal_connect ( screen, "monitors-changed", G_CALLBACK(panel_monitors_changed), (gpointer)p );
p->monitor = gdk_screen_get_primary_monitor(screen);
}
gtk_widget_realize(p->topgwin);
gdk_window_set_decorations(p->topgwin->window, 0);
gtk_widget_set_app_paintable(p->topgwin, TRUE);
p->lbox = p->my_box_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0);
gtk_container_add(GTK_CONTAINER(p->topgwin), p->lbox);
gtk_widget_show(p->lbox);
if (p->allign == ALLIGN_RIGHT) {
GtkWidget * expander = p->my_box_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(p->lbox), expander, TRUE, TRUE, 0);
gtk_widget_show(expander);
}
p->box = p->my_box_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(p->box), 1);
gtk_box_pack_start(GTK_BOX(p->lbox), p->box, FALSE, TRUE, padding);
gtk_widget_show(p->box);
// get properties on topgwin
p->topGdkWindow = gtk_widget_get_window(p->topgwin);
p->topxwin = GDK_WINDOW_XWINDOW(GTK_WIDGET(p->topgwin)->window);
bg_init(gdk_helper_display());
/* make our window unfocusable */
gdk_window_set_accept_focus(p->topGdkWindow,False);
if (p->setdocktype) {
gdk_window_set_type_hint(p->topGdkWindow,GDK_WINDOW_TYPE_HINT_DOCK);
}
Xclimsg(p->topxwin, a_NET_WM_DESKTOP, 0xFFFFFFFF, 0, 0, 0, 0);
/************************/
/* Window Mapping Point */
gtk_widget_show_all(p->topgwin);
Xclimsg(p->topxwin, a_NET_WM_DESKTOP, 0xFFFFFFFF, 0, 0, 0, 0);
gdk_window_stick ( p->topGdkWindow);
gdk_window_set_skip_pager_hint ( p->topGdkWindow, True );
gdk_window_set_skip_taskbar_hint ( p->topGdkWindow, True );
XSelectInput (gdk_helper_display(), GDK_ROOT_WINDOW(), PropertyChangeMask);
XSelectInput (gdk_helper_display(), p->topxwin, PropertyChangeMask | FocusChangeMask | StructureNotifyMask);
gdk_window_add_filter(gdk_get_default_root_window (), (GdkFilterFunc)panel_wm_events, p);
calculate_position(p, distance,distancefrom);
gdk_window_move_resize(p->topgwin->window, p->ax, p->ay, p->aw, p->ah);
if (p->setstrut)
panel_set_wm_strut(p);
if (p->lower)
XLowerWindow(gdk_helper_display(), p->topxwin);
RET();
}
void SetHexShape(int hex) {
int a;
XGCValues xgcv;
xgcv.function = GXxor;
XChangeGC(disp, TheScreen.HexMenu.ShapeGC, GCFunction, &xgcv);
XCopyArea(disp, TheScreen.HexMenu.ParentShape, TheScreen.HexMenu.ParentShape,
TheScreen.HexMenu.ShapeGC,
0, 0, TheScreen.HexMenu.width, TheScreen.HexMenu.height, 0,0);
xgcv.function = GXor;
XChangeGC(disp, TheScreen.HexMenu.ShapeGC, GCFunction, &xgcv);
for(a = 0; a < I_REALLY; a++) {
Pixmap shape;
int x, y;
shape = (a == hex) ? TheScreen.HexMenu.icons[a].IconSelectShape
: TheScreen.HexMenu.icons[a].IconShape;
x = (a == hex) ? TheScreen.HexMenu.icons[a].SelectX
: TheScreen.HexMenu.icons[a].x;
y = (a == hex) ? TheScreen.HexMenu.icons[a].SelectY
: TheScreen.HexMenu.icons[a].y;
if(a == hex) {
XRaiseWindow(disp, TheScreen.HexMenu.icons[a].IconWin);
} else {
XLowerWindow(disp, TheScreen.HexMenu.icons[a].IconWin);
}
XShapeCombineMask(disp, TheScreen.HexMenu.icons[a].IconWin, ShapeBounding,
0, 0, shape, ShapeUnion);
XMoveWindow(disp, TheScreen.HexMenu.icons[a].IconWin, x, y);
XShapeCombineMask(disp, TheScreen.HexMenu.icons[a].IconWin, ShapeBounding,
0, 0, shape, ShapeSet);
XCopyArea(disp, shape,
TheScreen.HexMenu.ParentShape, TheScreen.HexMenu.ShapeGC, 0, 0,
TheScreen.HexMenu.icons[a].width,
TheScreen.HexMenu.icons[a].height, x, y);
XSetWindowBackgroundPixmap(disp, TheScreen.HexMenu.icons[a].IconWin,
(a == hex)
? TheScreen.HexMenu.icons[a].IconSelectPix
: TheScreen.HexMenu.icons[a].IconPix);
XClearWindow(disp, TheScreen.HexMenu.icons[a].IconWin);
}
if(hex == I_REALLY || hex == I_KILL) {
Pixmap shape;
int x, y;
shape = (I_REALLY == hex)
? TheScreen.HexMenu.icons[I_REALLY].IconSelectShape
: TheScreen.HexMenu.icons[I_REALLY].IconShape;
x = (I_REALLY == hex) ? TheScreen.HexMenu.icons[I_REALLY].SelectX
: TheScreen.HexMenu.icons[I_REALLY].x;
y = (I_REALLY == hex) ? TheScreen.HexMenu.icons[I_REALLY].SelectY
: TheScreen.HexMenu.icons[I_REALLY].y;
XShapeCombineMask(disp, TheScreen.HexMenu.icons[I_REALLY].IconWin,
ShapeBounding, 0, 0, shape, ShapeSet);
XMoveWindow(disp, TheScreen.HexMenu.icons[I_REALLY].IconWin, x, y);
if(a == hex) {
XRaiseWindow(disp, TheScreen.HexMenu.icons[a].IconWin);
}
XMapWindow(disp, TheScreen.HexMenu.icons[I_REALLY].IconWin);
XCopyArea(disp, shape,
TheScreen.HexMenu.ParentShape, TheScreen.HexMenu.ShapeGC, 0, 0,
TheScreen.HexMenu.icons[I_REALLY].width,
TheScreen.HexMenu.icons[I_REALLY].height, x, y);
XSetWindowBackgroundPixmap(disp, TheScreen.HexMenu.icons[I_REALLY].IconWin,
(I_REALLY == hex)
? TheScreen.HexMenu.icons[I_REALLY]
.IconSelectPix
: TheScreen.HexMenu.icons[I_REALLY].IconPix);
XClearWindow(disp, TheScreen.HexMenu.icons[I_REALLY].IconWin);
} else {
XUnmapWindow(disp, TheScreen.HexMenu.icons[I_REALLY].IconWin);
}
XShapeCombineMask(disp, TheScreen.HexMenu.IconParent, ShapeBounding, 0, 0,
TheScreen.HexMenu.ParentShape, ShapeSet);
}
void WidgetImplWinGLX11::lower()
{
XLowerWindow( dpy, win );
}
