godzil/wmfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
wmfs/src/client.c
Martin Duquesnoy 07db3fafbd Menu: Fix item height
2010-04-22 17:56:35 +02:00

1286 lines
29 KiB
C
Raw Blame History

/*
* client.c
* Copyright © 2008, 2009 Martin Duquesnoy <xorg62@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of the nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "wmfs.h"
/** Attach client in the client chain
* \param c Client pointer
*/
void
client_attach(Client *c)
{
if(clients)
clients->prev = c;
c->next = clients;
clients = c;
return;
}
/** Send a ConfigureRequest event to the Client
* \param c Client pointer
*/
void
client_configure(Client *c)
{
XConfigureEvent ev;
ev.type = ConfigureNotify;
ev.event = c->win;
ev.window = c->win;
ev.x = c->geo.x;
ev.y = c->geo.y;
ev.width = c->geo.width;
ev.height = c->geo.height;
ev.above = None;
ev.border_width = 0;
ev.override_redirect = 0;
XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&ev);
return;
}
/** Detach a client to the client chain
* \param c Client pointer
*/
void
client_detach(Client *c)
{
Client **cc;
for(cc = &clients; *cc && *cc != c; cc = &(*cc)->next);
*cc = c->next;
return;
}
/** Get the next client
*\return The next client or NULL
*/
Client*
client_get_next(void)
{
Client *c = NULL;
if(!sel || ishide(sel, selscreen))
return NULL;
for(c = sel->next; c && ishide(c, selscreen); c = c->next);
if(!c && conf.client_round)
for(c = clients; c && ishide(c, selscreen); c = c->next);
return c;
}
/** Get the previous client
*\return The previous client or NULL
*/
Client*
client_get_prev(void)
{
Client *c = NULL, *d;
if(!sel || ishide(sel, selscreen))
return NULL;
for(d = clients; d != sel; d = d->next)
if(!ishide(d, selscreen))
c = d;
if(!c && conf.client_round)
for(; d; d = d->next)
if(!ishide(d, selscreen))
c = d;
return c;
}
/** Switch to the previous client
* \param cmd uicb_t type unused
*/
void
uicb_client_prev(uicb_t cmd)
{
Client *c;
if((c = client_get_prev()))
{
client_focus(c);
client_raise(c);
}
return;
}
/** Switch to the next client
* \param cmd uicb_t type unused
*/
void
uicb_client_next(uicb_t cmd)
{
Client *c;
if((c = client_get_next()))
{
client_focus(c);
client_raise(c);
}
return;
}
/** Swap the current client with the next one
*\param cmd uicb_t type unused
*/
void
uicb_client_swap_next(uicb_t cmd)
{
Client *c;
if((c = client_get_next()))
{
client_swap(sel, c);
client_focus(c);
}
return;
}
/** Swap the current client with the previous one
*\param cmd uicb_t type unused
*/
void
uicb_client_swap_prev(uicb_t cmd)
{
Client *c;
if((c = client_get_prev()))
{
client_swap(sel, c);
client_focus(c);
}
return;
}
/** Set the client c above
*\param c Client pointer
*/
void
client_above(Client *c)
{
XRectangle geo = { 0 };
if(c->flags & AboveFlag)
return;
c->flags |= AboveFlag;
geo.height = spgeo[c->screen].height * 0.75;
geo.width = spgeo[c->screen].width * 0.75;
geo.y = spgeo[c->screen].y + (spgeo[c->screen].height / 2) - (geo.height / 2);
geo.x = spgeo[c->screen].x + (spgeo[c->screen].width / 2)- (geo.width / 2);
client_moveresize(c, geo, tags[c->screen][c->tag].resizehint);
client_raise(c);
tags[c->screen][c->tag].layout.func(c->screen);
return;
}
/** Set the focus to a client
* \param c Client pointer
*/
void
client_focus(Client *c)
{
Window w;
int d;
if(sel && sel != c)
{
sel->colors.frame = conf.client.bordernormal;
sel->colors.fg = conf.titlebar.fg_normal;
sel->colors.resizecorner = conf.client.resizecorner_normal;
if(TBARH - BORDH && sel->titlebar->stipple)
sel->titlebar->stipple_color = conf.titlebar.stipple.colors.normal;
if(sel->flags & AboveFlag)
sel->flags &= ~AboveFlag;
frame_update(sel);
mouse_grabbuttons(sel, !conf.focus_pclick);
}
if((sel = c))
{
c->colors.frame = conf.client.borderfocus;
c->colors.fg = conf.titlebar.fg_focus;
c->colors.resizecorner = conf.client.resizecorner_focus;
if(TBARH - BORDH && c->titlebar->stipple)
c->titlebar->stipple_color = conf.titlebar.stipple.colors.focus;
frame_update(c);
mouse_grabbuttons(c, True);
if(conf.raisefocus)
{
XQueryPointer(dpy, ROOT, &w, &w, &d, &d, &d, &d, (uint *)&d);
if(c == client_gb_win(w)
|| c == client_gb_frame(w)
|| c == client_gb_titlebar(w))
client_raise(c);
}
if(tags[sel->screen][sel->tag].abovefc && !conf.focus_fmouse)
client_above(sel);
if(c->flags & UrgentFlag)
{
c->flags &= ~UrgentFlag;
tags[c->screen][c->tag].urgent = False;
infobar_draw_taglist(c->screen);
}
XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
if(conf.bars.selbar)
infobar_draw_selbar(sel->screen);
}
else
{
XSetInputFocus(dpy, ROOT, RevertToPointerRoot, CurrentTime);
if(conf.bars.selbar)
infobar_draw_selbar(selscreen);
}
return;
}
/* The following functions have the same point :
* find a client member with a Window {{{
*/
/* Get Client with a window */
/** Get a client->win with a window
* \param w Window
* \return The client
*/
Client* client_gb_win(Window w)
{
Client *c;
for(c = clients; c && c->win != w; c = c->next);
return c;
}
/** Get a client->frame with a window
* \param w Window
* \return The client
*/
Client* client_gb_frame(Window w)
{
Client *c;
for(c = clients; c && c->frame != w; c = c->next);
return c;
}
/** Get a client->titlebar with a window
* \param w Window
* \return The client
*/
Client* client_gb_titlebar(Window w)
{
Client *c;
if(!(TBARH - BORDH))
return NULL;
for(c = clients; c && c->titlebar->win != w; c = c->next);
return c;
}
/** Get a client->resize with a window
* \param w Window
* \return The client
*/
Client* client_gb_resize(Window w)
{
Client *c;
for(c = clients; (c && c->resize[Right] != w) && (c && c->resize[Left] != w); c = c->next);
return c;
}
/** Get a client->button[button_num] with a window
* \param w Window
* \param n Pointer who return the button_num
* \return The client
*/
Client* client_gb_button(Window w, int *n)
{
Client *c;
int i;
if(!BUTTONWH || !(TBARH - BORDH))
return NULL;
for(c = clients; c; c = c->next)
for(i = 0; i < conf.titlebar.nbutton; ++i)
if(c->button[i] == w)
{
*n = i;
return c;
}
return NULL;
}
/* }}} */
/** Get a client name
* \param c Client pointer
*/
void
client_get_name(Client *c)
{
Atom rt;
int rf;
ulong ir, il;
IFREE(c->title);
/* This one instead XFetchName for utf8 name support */
if(XGetWindowProperty(dpy, c->win, net_atom[net_wm_name], 0, 4096,
False, net_atom[utf8_string], &rt, &rf, &ir, &il, (uchar**)&c->title) != Success)
XGetWindowProperty(dpy, c->win, ATOM("WM_NAME"), 0, 4096,
False, net_atom[utf8_string], &rt, &rf, &ir, &il, (uchar**)&c->title);
/* If there is no title... */
if(!c->title)
{
XFetchName(dpy, c->win, &(c->title));
if(!c->title)
c->title = _strdup("WMFS");
}
frame_update(c);
if(conf.bars.selbar && c == sel)
infobar_draw_selbar(c->screen);
return;
}
/** Hide a client (for tag switching)
* \param c Client pointer
*/
void
client_hide(Client *c)
{
CHECK(!(c->flags & HideFlag));
client_unmap(c);
c->flags |= HideFlag;
setwinstate(c->win, IconicState);
return;
}
/** Check if the client 'c' is hide
* \param c Client pointer
* \return True if the client is hide; False if not
*/
Bool
ishide(Client *c, int screen)
{
if(((c->tag == seltag[screen] || c->tag == MAXTAG + 1) && c->screen == screen)
|| tags[screen][seltag[screen]].tagad & TagFlag(c->tag))
return False;
return True;
}
/** Kill a client
* \param c Client pointer
*/
void
client_kill(Client *c)
{
XEvent ev;
Atom *atom = NULL;
int proto;
int canbedel = 0;
CHECK(c);
if(XGetWMProtocols(dpy, c->win, &atom, &proto) && atom)
{
while(proto--)
if(atom[proto] == ATOM("WM_DELETE_WINDOW"))
++canbedel;
XFree(atom);
if(canbedel)
{
ev.type = ClientMessage;
ev.xclient.window = c->win;
ev.xclient.message_type = ATOM("WM_PROTOCOLS");
ev.xclient.format = 32;
ev.xclient.data.l[0] = ATOM("WM_DELETE_WINDOW");
ev.xclient.data.l[1] = CurrentTime;
ev.xclient.data.l[2] = 0;
ev.xclient.data.l[3] = 0;
ev.xclient.data.l[4] = 0;
XSendEvent(dpy, c->win, False, NoEventMask, &ev);
}
else
XKillClient(dpy, c->win);
}
else
XKillClient(dpy, c->win);
return;
}
/** Kill the selected client
* \param cmd uicb_t type unused
*/
void
uicb_client_kill(uicb_t cmd)
{
CHECK(sel);
client_kill(sel);
return;
}
/** Map a client
* \param c Client pointer
*/
void
client_map(Client *c)
{
CHECK(c);
if(c->flags & FSSFlag)
XMapWindow(dpy, c->win);
else
{
XMapWindow(dpy, c->frame);
XMapSubwindows(dpy, c->frame);
if(TBARH - BORDH)
{
barwin_map(c->titlebar);
barwin_map_subwin(c->titlebar);
}
XMapSubwindows(dpy, c->frame);
c->flags &= ~UnmapFlag;
}
return;
}
/** Manage a client with a window and his attributes
* \param w Cient's futur Window
* \param wa XWindowAttributes pointer, Window w attributes
* \param ar Do arrange() or not (Bool)
* \return The managed client
*/
Client*
client_manage(Window w, XWindowAttributes *wa, Bool ar)
{
Client *c, *t = NULL;
Window trans, dw;
Status rettrans;
XSetWindowAttributes at;
int mx, my, dint;
uint duint;
screen_get_sel();
c = emalloc(1, sizeof(Client));
c->win = w;
c->screen = selscreen;
c->flags = 0;
XQueryPointer(dpy, ROOT, &dw, &dw, &mx, &my, &dint, &dint, &duint);
if(conf.client.place_at_mouse)
{
mx += BORDH;
my += TBARH;
if((MAXW - mx) < wa->width)
mx -= wa->width + BORDH;
if((MAXH - my) < wa->height)
my -= wa->height + TBARH;
}
else
{
mx = wa->x + BORDH;
my = wa->y + TBARH + INFOBARH;
/* Check if the client is already in the selected
* screen, else place the client in it */
if(screen_get_with_geo(mx, my) != selscreen)
{
mx += spgeo[selscreen].x;
my += spgeo[selscreen].y;
}
}
c->ogeo.x = c->geo.x = mx;
c->ogeo.y = c->geo.y = my;
c->ogeo.width = c->geo.width = wa->width;
c->ogeo.height = c->geo.height = wa->height;
c->free_geo = c->geo;
c->tag = seltag[c->screen];
c->layer = (sel && sel->layer > 0) ? sel->layer : 1;
at.event_mask = PropertyChangeMask;
frame_create(c);
client_size_hints(c);
XChangeWindowAttributes(dpy, c->win, CWEventMask, &at);
/* client win should _not_ have borders */
XSetWindowBorderWidth(dpy, c->win, 0);
mouse_grabbuttons(c, False);
/* Transient */
if((rettrans = XGetTransientForHint(dpy, w, &trans) == Success))
for(t = clients; t && t->win != trans; t = t->next);
if(t)
{
c->tag = t->tag;
c->screen = t->screen;
}
if(!(c->flags & FreeFlag)
&& (rettrans == Success || (c->flags & HintFlag)))
c->flags |= FreeFlag;
free(t);
client_attach(c);
client_get_name(c);
client_map(c);
client_raise(c);
client_focus(c);
setwinstate(c->win, NormalState);
ewmh_get_client_list();
ewmh_manage_window_type(c);
client_set_wanted_tag(c);
client_update_attributes(c);
if(ar)
arrange(c->screen, True);
if(!conf.client.set_new_win_master)
layout_set_client_master(c);
return c;
}
/** Set a geometry with the client size hints
*\param geo Geometry pointer
*\param c Client pointer
*/
void
client_geo_hints(XRectangle *geo, Client *c)
{
/* minimum possible */
if(geo->width < 1)
geo->width = 1;
if(geo->height < 1)
geo->height = 1;
/* base */
geo->width -= c->basew;
geo->height -= c->baseh;
/* aspect */
if(c->minay > 0 && c->maxay > 0
&& c->minax > 0 && c->maxax > 0)
{
if(geo->width * c->maxay > geo->height * c->maxax)
geo->width = geo->height * c->maxax / c->maxay;
else if(geo->width * c->minay < geo->height * c->minax)
geo->height = geo->width * c->minay / c->minax;
}
/* incremental */
if(c->incw)
geo->width -= geo->width % c->incw;
if(c->inch)
geo->height -= geo->height % c->inch;
/* base dimension */
geo->width += c->basew;
geo->height += c->baseh;
if(c->minw > 0 && geo->width < c->minw)
geo->width = c->minw;
if(c->minh > 0 && geo->height < c->minh)
geo->height = c->minh;
if(c->maxw > 0 && geo->width > c->maxw)
geo->width = c->maxw;
if(c->maxh > 0 && geo->height > c->maxh)
geo->height = c->maxh;
return;
}
/** Move and Resize a client
* \param c Client pointer
* \param geo Coordinate info for the future size
* of the client
* \param r Bool for resize hint or not
*/
void
client_moveresize(Client *c, XRectangle geo, Bool r)
{
int os;
if(!c)
return;
os = c->screen;
if(r)
client_geo_hints(&geo, c);
c->flags &= ~MaxFlag;
c->geo = c->ogeo = geo;
if(c->flags & FreeFlag || tags[c->screen][c->tag].layout.func == freelayout)
c->free_geo = geo;
if((c->screen = screen_get_with_geo(c->geo.x, c->geo.y)) != os
&& c->tag != MAXTAG + 1)
c->tag = seltag[c->screen];
frame_moveresize(c, c->geo);
XMoveResizeWindow(dpy, c->win, BORDH, TBARH, c->geo.width, c->geo.height);
client_configure(c);
client_update_attributes(c);
return;
}
/** Maximize a client
* \param c Client pointer
*/
void
client_maximize(Client *c)
{
XRectangle geo;
if(!c || c->flags & FSSFlag)
return;
c->screen = screen_get_with_geo(c->geo.x, c->geo.y);
geo.x = sgeo[c->screen].x;
geo.y = sgeo[c->screen].y;
geo.width = sgeo[c->screen].width - BORDH * 2;
geo.height = sgeo[c->screen].height - BORDH;
client_moveresize(c, geo, False);
return;
}
/** Get client size hints
* \param c Client pointer
*/
void
client_size_hints(Client *c)
{
long msize;
XSizeHints size;
if(!XGetWMNormalHints(dpy, c->win, &size, &msize) || !size.flags)
size.flags = PSize;
/* base */
if(size.flags & PBaseSize)
{
c->basew = size.base_width;
c->baseh = size.base_height;
}
else if(size.flags & PMinSize)
{
c->basew = size.min_width;
c->baseh = size.min_height;
}
else
c->basew = c->baseh = 0;
/* inc */
if(size.flags & PResizeInc)
{
c->incw = size.width_inc;
c->inch = size.height_inc;
}
else
c->incw = c->inch = 0;
/* max */
if(size.flags & PMaxSize)
{
c->maxw = size.max_width;
c->maxh = size.max_height;
}
else
c->maxw = c->maxh = 0;
/* min */
if(size.flags & PMinSize)
{
c->minw = (size.min_width ? size.min_width : 1);
c->minh = (size.min_height ? size.min_height: 1);
}
else if(size.flags & PBaseSize)
{
c->minw = (size.base_width ? size.base_width : 1);
c->minh = (size.base_height ? size.base_height : 1);
}
else
c->minw = c->minh = 0;
/* aspect */
if(size.flags & PAspect)
{
c->minax = size.min_aspect.x;
c->maxax = size.max_aspect.x;
c->minay = size.min_aspect.y;
c->maxay = size.max_aspect.y;
}
else
c->minax = c->maxax = c->minay = c->maxay = 0;
if(c->maxw && c->minw && c->maxh && c->minh
&& c->maxw == c->minw && c->maxh == c->minh)
c->flags |= HintFlag;
return;
}
/** Swap two clients
*\param 1 c1 First client
*\param 2 c2 Second client
*/
void
client_swap(Client *c1, Client *c2)
{
/* Check if no one of these clients are free */
CHECK(!(c1->flags & FreeFlag));
CHECK(!(c2->flags & FreeFlag));
if(c1 == c2 || (c1->screen == c2->screen && c1->tag != c2->tag))
return;
/* Swap only the windows */
swap_ptr((void**)&c1->win, (void**)&c2->win);
/* Re-adapt the windows position with its new frame */
XReparentWindow(dpy, c1->win, c1->frame, BORDH, TBARH);
XReparentWindow(dpy, c2->win, c2->frame, BORDH, TBARH);
/* Re-set size hints properties */
client_size_hints(c1);
client_size_hints(c2);
/* Resize the windows */
client_moveresize(c1, c1->geo, False);
client_moveresize(c2, c2->geo, False);
/* Get the new client name */
client_get_name(c1);
client_get_name(c2);
return;
}
/** Set the wanted tag of a client
*\param c Client pointer
*/
void
client_set_wanted_tag(Client *c)
{
XClassHint xch = { 0 };
int i, j, k;
if(conf.ignore_next_client_rules)
{
conf.ignore_next_client_rules = False;
return;
}
XGetClassHint(dpy, c->win, &xch);
for(i = 0; i < screen_count(); ++i)
for(j = 1; j < conf.ntag[i] + 1; ++j)
if(tags[i][j].clients)
for(k = 0; k < tags[i][j].nclients; ++k)
if((xch.res_name && strstr(xch.res_name, tags[i][j].clients[k]))
|| (xch.res_class && strstr(xch.res_class, tags[i][j].clients[k])))
{
c->screen = i;
c->tag = j;
if(c->tag != seltag[selscreen])
{
tags[c->screen][c->tag].request_update = True;
client_focus(NULL);
}
tags[c->screen][c->tag].layout.func(c->screen);
}
return;
}
/** Update client attributes (_WMFS_TAG _WMFS_SCREEN)
*\param c Client pointer
*/
void
client_update_attributes(Client *c)
{
Bool f;
/* For reload use */
XChangeProperty(dpy, c->win, ATOM("_WMFS_TAG"), XA_CARDINAL, 32,
PropModeReplace, (uchar*)&(c->tag), 1);
XChangeProperty(dpy, c->win, ATOM("_WMFS_SCREEN"), XA_CARDINAL, 32,
PropModeReplace, (uchar*)&(c->screen), 1);
f = (c->flags & FreeFlag);
XChangeProperty(dpy, c->win, ATOM("_WMFS_ISFREE"), XA_CARDINAL, 32,
PropModeReplace, (uchar*)&f, 1);
return;
}
/** Raise a client
* \param c Client pointer
*/
void
client_raise(Client *c)
{
if(!c || ((c->flags & TileFlag) && !(c->flags & AboveFlag)))
return;
XRaiseWindow(dpy, c->frame);
return;
}
/** Raise the selected client
* \param cmd uicb_t type unused
*/
void
uicb_client_raise(uicb_t cmd)
{
CHECK(sel);
client_raise(sel);
return;
}
/** UnHide a client (for tag switching)
* \param c Client pointer
*/
void
client_unhide(Client *c)
{
CHECK(c->flags & HideFlag);
client_map(c);
c->flags &= ~HideFlag;
setwinstate(c->win, NormalState);
return;
}
/** Unmanage a client
* \param c Client pointer
*/
void
client_unmanage(Client *c)
{
Client *c_next = NULL;
Bool b = False;
int i;
XGrabServer(dpy);
XSetErrorHandler(errorhandlerdummy);
XReparentWindow(dpy, c->win, ROOT, c->geo.x, c->geo.y);
if(sel == c)
client_focus(NULL);
client_detach(c);
XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
setwinstate(c->win, WithdrawnState);
frame_delete(c);
XSync(dpy, False);
XUngrabServer(dpy);
ewmh_get_client_list();
/* Arrange */
for(i = 0; i < screen_count() && !b; ++i)
if(c->tag == seltag[i])
b = True;
if(b)
tags[c->screen][c->tag].layout.func(c->screen);
else
{
tags[c->screen][c->tag].request_update = True;
infobar_draw(c->screen);
}
XFree(c->title);
/* To focus the previous client */
for(c_next = clients;
c_next && c_next != c->prev
&& c_next->tag != c->tag
&& c_next->screen != c->screen;
c_next = c_next->next);
if(c_next && c_next->tag == seltag[selscreen]
&& c_next->screen == selscreen)
client_focus(c_next);
free(c);
return;
}
/** Unmap a client
* \param c Client pointer
*/
void
client_unmap(Client *c)
{
CHECK(c);
if(c->flags & FSSFlag)
XUnmapWindow(dpy, c->win);
else
{
if(TBARH - BORDH)
{
barwin_unmap_subwin(c->titlebar);
barwin_unmap(c->titlebar);
}
XUnmapWindow(dpy, c->frame);
XUnmapSubwindows(dpy, c->frame);
c->flags |= UnmapFlag;
}
return;
}
/** Set the client screen
*\param c Client pointer
*\param s Screen id
*/
void
client_set_screen(Client *c, int s)
{
int os;
XRectangle geo;
if(!c || s < 0 || s > screen_count() - 1 || s == c->screen)
return;
/* Save old client screen/geo to arrange */
geo = c->geo;
os = c->screen;
c->screen = s;
c->tag = seltag[s];
/* Arrange */
if(tags[s][seltag[s]].layout.func == freelayout
|| tags[s][seltag[s]].layout.func == maxlayout
|| tags[os][seltag[os]].layout.func == freelayout
|| tags[os][seltag[os]].layout.func == maxlayout)
{
geo.x = (sgeo[s].x + sgeo[s].width / 2) - (c->geo.width / 2);
geo.y = (sgeo[s].y + sgeo[s].height / 2) - (c->geo.height / 2);
client_moveresize(c, geo, False);
}
arrange(s, True);
arrange(os, True);
if(!(c->flags & TileFlag))
{
client_focus(c);
client_raise(c);
}
return;
}
/** Change client of screen to next screen
* \param cmd uicb_t type unused
*/
void
uicb_client_screen_next(uicb_t cmd)
{
CHECK(sel);
client_set_screen(sel, (sel->screen + 1 > screen_count() - 1) ? 0 : sel->screen + 1);
return;
}
/** Change client of screen to prev screen
* \param cmd uicb_t type unused
*/
void
uicb_client_screen_prev(uicb_t cmd)
{
CHECK(sel);
client_set_screen(sel, (sel->screen - 1 < 0) ? screen_count() - 1 : sel->screen - 1);
return;
}
/** Move a client
*\param cmd uicb_t type
*/
void
uicb_client_move(uicb_t cmd)
{
XRectangle geo;
int xi = 0, yi = 0;
if((sel->flags & TileFlag)
|| (sel->flags & MaxFlag)
|| (sel->flags & LMaxFlag)
|| (sel->flags & FSSFlag)
|| !sel)
return;
geo = sel->geo;
if(sscanf(cmd, "%d %d", &xi, &yi))
{
geo.x += xi;
geo.y += yi;
client_moveresize(sel, geo, False);
}
return;
}
/** Resize a client
*\param cmd uicb_t type
*/
void
uicb_client_resize(uicb_t cmd)
{
XRectangle geo;
int wi = 0, hi = 0;
if((sel->flags & TileFlag)
|| (sel->flags & MaxFlag)
|| (sel->flags & LMaxFlag)
|| (sel->flags & FSSFlag)
|| !sel)
return;
geo = sel->geo;
if(sscanf(cmd, "%d %d", &wi, &hi))
{
geo.width += ((geo.width + wi > sel->minw && geo.width + wi < 65536) ? wi : 0);
geo.height += ((geo.height + hi > sel->minh && geo.height + hi < 65536) ? hi : 0);
client_moveresize(sel, geo, False);
}
return;
}
/** Ignore next client rules
*\param cmd uicb_t type
*/
void
uicb_ignore_next_client_rules(uicb_t cmd)
{
conf.ignore_next_client_rules = !conf.ignore_next_client_rules;
return;
}
/** Show clientlist menu
*\param cmd uicb_t type
*/
void
uicb_clientlist(uicb_t cmd)
{
int i, d, u, x, y;
int n = 0;
Window w;
Client *c = NULL;
screen_get_sel();
for(c = clients; c; c = c->next)
if(!ishide(c, selscreen))
++n;
if(n > 0)
{
if(clientlist.nitem)
menu_clear(&clientlist);
menu_init(&clientlist, "clientlist", n,
/* Colors */
conf.colors.tagselbg,
conf.colors.tagselfg,
conf.colors.bar,
conf.colors.text);
for(i = 0, c = clients; c; c = c->next)
if(!ishide(c, selscreen))
{
sprintf(clist_index[i].key, "%d", i);
clist_index[i].client = c;
menu_new_item(&clientlist.item[i], c->title,
uicb_client_select, clist_index[i].key);
if(c == sel)
clientlist.item[i].check = name_to_func("check_clist", func_list);
i++;
}
clist_index[i].client = NULL;
XQueryPointer(dpy, ROOT, &w, &w, &x, &y, &d, &d, (uint *)&u);
menu_draw(clientlist, x, y);
}
return;
}
/** Select client
*\param cmd uicb_t type clientlist index
*/
void
uicb_client_select(uicb_t cmd)
{
int i;
Window w;
int d, x, y;
for(i = 0; i < MAXCLIST && clist_index[i].client; ++i)
if(!strcmp(cmd, clist_index[i].key))
{
client_focus(clist_index[i].client);
client_raise(clist_index[i].client);
/* Move pointer on client */
XQueryPointer(dpy, ROOT, &w, &w, &x, &y, &d, &d, (uint *)&d);
XWarpPointer(dpy, ROOT, ROOT, x, y, d, d,
clist_index[i].client->geo.x + clist_index[i].client->geo.width / 2,
clist_index[i].client->geo.y + clist_index[i].client->geo.height / 2);
}
return;
}
/** Check clientlist menu fake function
* \param cmd uicb_t type unused
*/
Bool
uicb_checkclist(uicb_t cmd)
{
return True;
}
/** Set selected client on all tag (ignore tags
*\para cmd uicb_t type unused
*/
void
uicb_client_ignore_tag(uicb_t cmd)
{
CHECK(sel);
screen_get_sel();
sel->tag = ((sel->tag == MAXTAG + 1) ? seltag[selscreen] : MAXTAG + 1);
arrange(sel->screen, True);
return;
}
Reference in New Issue View Git Blame Copy Permalink