static EImage *
pt_get_bg_image(Win win, int w, int h, int use_root)
{
EImage *ii = NULL;
Win cr;
EX_Drawable bg;
int xx, yy;
bg = DeskGetBackgroundPixmap(DesksGetCurrent());
if (use_root || bg == NoXID)
{
cr = VROOT;
bg = WinGetXwin(VROOT);
}
else
{
cr = EoGetWin(DesksGetCurrent());
}
ETranslateCoordinates(win, cr, 0, 0, &xx, &yy, NULL);
#if 0
Eprintf("%s: %#x %d %d %d %d\n", __func__, WinGetXwin(win), xx, yy, w, h);
#endif
if (xx < WinGetW(VROOT) && yy < WinGetH(VROOT) && xx + w >= 0 && yy + h >= 0)
{
/* Create the background base image */
ii = EImageGrabDrawable(bg, NoXID, xx, yy, w, h, !EServerIsGrabbed());
}
return ii;
}
void
HintsInit(void)
{
Window win;
AtomListIntern(atoms_misc_names, N_ITEMS(atoms_misc_names), atoms_misc);
win = XCreateSimpleWindow(disp, WinGetXwin(VROOT), -200, -200, 5, 5,
0, 0, 0);
ICCCM_Init();
MWM_SetInfo();
#if ENABLE_GNOME
GNOME_SetHints(win);
#endif
EWMH_Init(win);
ecore_x_window_prop_string_set(WinGetXwin(VROOT), E16_ATOM_VERSION,
e_wm_version);
if (Mode.wm.window)
{
HintsSetWindowName(VROOT, "Enlightenment");
HintsSetWindowClass(VROOT, "Virtual-Root", "Enlightenment");
}
Mode.root.ext_pmap = HintsGetRootPixmap(VROOT);
Mode.root.ext_pmap_valid = EDrawableCheck(Mode.root.ext_pmap, 0);
}
static ECursor *
ECursorRealize(ECursor * ec)
{
Pixmap pmap, mask;
int xh, yh;
unsigned int w, h, ww, hh;
char *img, msk[FILEPATH_LEN_MAX];
if (ec->file)
{
img = ThemeFileFind(ec->file, FILE_TYPE_CURSOR);
_EFREE(ec->file); /* Ok or not - we never need file again */
if (!img)
goto done;
Esnprintf(msk, sizeof(msk), "%s.mask", img);
pmap = 0;
mask = 0;
xh = 0;
yh = 0;
XReadBitmapFile(disp, WinGetXwin(VROOT), msk, &w, &h, &mask, &xh, &yh);
XReadBitmapFile(disp, WinGetXwin(VROOT), img, &w, &h, &pmap, &xh, &yh);
XQueryBestCursor(disp, WinGetXwin(VROOT), w, h, &ww, &hh);
if ((w <= ww) && (h <= hh) && (pmap))
{
if (xh < 0 || xh >= (int)w)
xh = (int)w / 2;
if (yh < 0 || yh >= (int)h)
yh = (int)h / 2;
ec->cursor =
ECreatePixmapCursor(pmap, mask, w, h, xh, yh, ec->fg, ec->bg);
}
if (ec->cursor == NoXID)
{
Eprintf("*** Failed to create cursor \"%s\" from %s,%s\n",
ec->name, img, msk);
}
if (pmap)
EFreePixmap(pmap);
if (mask)
EFreePixmap(mask);
Efree(img);
}
else
{
ec->cursor = (ec->native_id == 999) ?
None : XCreateFontCursor(disp, ec->native_id);
}
done:
if (ec->cursor == NoXID)
{
ECursorDestroy(ec);
ec = NULL;
}
return ec;
}
int
GrabPointerSet(Win win, unsigned int csr, int confine __UNUSED__)
{
int rc;
#if USE_XI2
EXIEventMask em;
EXIMaskSetup(&em, DEV_PTR,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask);
rc = XIGrabDevice(disp, DEV_PTR, WinGetXwin(win), CurrentTime, ECsrGet(csr),
GrabModeAsync, GrabModeAsync, False, &em.em);
#else
EX_Window confine_to = (confine) ? WinGetXwin(VROOT) : NoXID;
rc = XGrabPointer(disp, WinGetXwin(win), False,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
ButtonMotionMask | EnterWindowMask | LeaveWindowMask,
GrabModeAsync, GrabModeAsync, confine_to, ECsrGet(csr),
CurrentTime);
#endif
Mode.grabs.pointer_grab_window = WinGetXwin(win);
Mode.grabs.pointer_grab_active = 1;
if (EDebug(EDBUG_TYPE_GRABS))
Eprintf("%s: %#x, rc=%d\n", __func__, Mode.grabs.pointer_grab_window, rc);
return rc;
}
void
GrabButtonSet(unsigned int button, unsigned int modifiers, Win win,
unsigned int event_mask, unsigned int csr, int confine)
{
Bool owner_events = False;
int pointer_mode = GrabModeSync;
int keyboard_mode = GrabModeAsync;
Window confine_to = (confine) ? WinGetXwin(win) : None;
int i;
if (modifiers == AnyModifier)
{
XGrabButton(disp, button, modifiers,
WinGetXwin(win), owner_events, event_mask, pointer_mode,
keyboard_mode, confine_to, ECsrGet(csr));
return;
}
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
XGrabButton(disp, button, modifiers | Mode.masks.mod_combos[i],
WinGetXwin(win), owner_events, event_mask, pointer_mode,
keyboard_mode, confine_to, ECsrGet(csr));
}
}
void
GrabButtonSet(unsigned int button, unsigned int modifiers, Win win,
unsigned int event_mask, unsigned int csr, int confine __UNUSED__)
{
Bool owner_events = False;
int pointer_mode = GrabModeSync;
int keyboard_mode = GrabModeAsync;
int i;
#if USE_XI2
EXIEventMask em;
XIGrabModifiers modifiers_inouts[8];
int num_modifiers;
EXIMaskSetup(&em, DEV_PTR, event_mask);
if (modifiers == AnyModifier)
{
num_modifiers = 1;
modifiers_inouts[0].modifiers = XIAnyModifier;
modifiers_inouts[0].status = 0;
}
else
{
num_modifiers = 0;
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
modifiers_inouts[num_modifiers].modifiers =
modifiers | Mode.masks.mod_combos[i];
modifiers_inouts[num_modifiers].status = 0;
num_modifiers++;
}
}
XIGrabButton(disp, DEV_PTR, button, WinGetXwin(win), ECsrGet(csr),
pointer_mode, keyboard_mode, owner_events,
&em.em, num_modifiers, modifiers_inouts);
#else
EX_Window confine_to = (confine) ? WinGetXwin(win) : NoXID;
if (modifiers == AnyModifier)
{
XGrabButton(disp, button, modifiers,
WinGetXwin(win), owner_events, event_mask, pointer_mode,
keyboard_mode, confine_to, ECsrGet(csr));
return;
}
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
XGrabButton(disp, button, modifiers | Mode.masks.mod_combos[i],
WinGetXwin(win), owner_events, event_mask, pointer_mode,
keyboard_mode, confine_to, ECsrGet(csr));
}
#endif
}
void
HintsSetWindowName(Win win, const char *name)
{
if (!name)
return;
ecore_x_icccm_title_set(WinGetXwin(win), name);
EWMH_SetWindowName(WinGetXwin(win), name);
}
void
GrabKeySet(unsigned int keycode, unsigned int modifiers, Win win)
{
Bool owner_events = False;
int pointer_mode = GrabModeAsync;
int keyboard_mode = GrabModeSync;
int i;
#if USE_XI2
EXIEventMask em;
XIGrabModifiers modifiers_inouts[8];
int num_modifiers;
EXIMaskSetup(&em, DEV_KBD, KeyPressMask | KeyReleaseMask);
if (modifiers == AnyModifier)
{
num_modifiers = 1;
modifiers_inouts[0].modifiers = XIAnyModifier;
modifiers_inouts[0].status = 0;
}
else
{
num_modifiers = 0;
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
modifiers_inouts[num_modifiers].modifiers =
modifiers | Mode.masks.mod_combos[i];
modifiers_inouts[num_modifiers].status = 0;
num_modifiers++;
}
}
XIGrabKeycode(disp, DEV_KBD, keycode, WinGetXwin(win),
keyboard_mode, pointer_mode, owner_events,
&em.em, num_modifiers, modifiers_inouts);
#else
if (modifiers == AnyModifier)
{
XGrabKey(disp, keycode, modifiers, WinGetXwin(win), owner_events,
pointer_mode, keyboard_mode);
return;
}
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
XGrabKey(disp, keycode, modifiers | Mode.masks.mod_combos[i],
WinGetXwin(win), owner_events, pointer_mode, keyboard_mode);
}
#endif
}
static void
ExtInitRR(int available)
{
Rotation rot;
if (!available)
return;
/* Listen for RandR events */
XRRSelectInput(disp, WinGetXwin(VROOT), RRScreenChangeNotifyMask);
XRRRotations(disp, Dpy.screen, &rot);
Mode.screen.rotation = rot;
#if 0 /* Debug */
if (EDebug(EDBUG_TYPE_VERBOSE))
{
XRRScreenResources *psr;
XRRCrtcInfo *pci;
XRROutputInfo *poi;
int i;
psr = XRRGetScreenResources(disp, WinGetXwin(VROOT));
if (!psr)
return;
Eprintf("CRTC ID X,Y WxH mode rot nout\n");
for (i = 0; i < psr->ncrtc; i++)
{
pci = XRRGetCrtcInfo(disp, psr, psr->crtcs[i]);
if (!pci)
break;
Eprintf("%3d %#04lx %4d,%4d %4ux%4u %#04lx %4d %5d\n",
i, psr->crtcs[i],
pci->x, pci->y, pci->width, pci->height,
pci->mode, pci->rotation, pci->noutput);
XRRFreeCrtcInfo(pci);
}
Eprintf("OUTP ID Name WxH crtc ncrtc nclon nmode\n");
for (i = 0; i < psr->noutput; i++)
{
poi = XRRGetOutputInfo(disp, psr, psr->outputs[i]);
if (!poi)
break;
Eprintf("%3d %#04lx %-8s %4lux%4lu %#04lx %4d %5d %5d\n",
i, psr->outputs[i],
poi->name, poi->mm_width, poi->mm_height,
poi->crtc, poi->ncrtc, poi->nclone, poi->nmode);
XRRFreeOutputInfo(poi);
}
XRRFreeScreenResources(psr);
}
#endif
}
int
GrabKeyboardSet(Win win)
{
int rc;
rc =
XGrabKeyboard(disp, WinGetXwin(win), False, GrabModeAsync, GrabModeAsync,
CurrentTime);
#if 0
Eprintf("GrabKeyboardSet %#lx %d\n", WinGetXwin(win), rc);
#endif
return rc;
}
void
ECursorApply(ECursor * ec, Win win)
{
if (!ec)
return;
XDefineCursor(disp, WinGetXwin(win), ec->cursor);
}
static void
_eiw_render_loop(Window win, EImage * im, EiwData * d)
{
int w, h;
XRenderPictFormat *pictfmt;
Pixmap pmap;
Picture pict;
EImageGetSize(im, &w, &h);
pictfmt = XRenderFindStandardFormat(disp, PictStandardARGB32);
pmap = XCreatePixmap(disp, WinGetXwin(VROOT), w, h, 32);
imlib_context_set_image(im);
imlib_context_set_drawable(pmap);
imlib_render_image_on_drawable(0, 0);
pict = XRenderCreatePicture(disp, pmap, pictfmt, 0, 0);
XFreePixmap(disp, pmap);
if (d->curs != None)
XFreeCursor(disp, d->curs);
d->curs = XRenderCreateCursor(disp, pict, w / 2, h / 2);
XRenderFreePicture(disp, pict);
XDefineCursor(disp, win, d->curs);
}
Win
ECreateArgbWindow(Win parent, int x, int y, int w, int h, Win cwin)
{
int depth;
Visual *vis;
Colormap cmap;
if (cwin && Conf.testing.argb_clients_inherit_attr)
{
depth = cwin->depth;
vis = cwin->visual;
cmap = cwin->cmap;
}
else
{
if (!argb_visual)
{
argb_visual = EVisualFindARGB();
argb_cmap =
XCreateColormap(disp, WinGetXwin(VROOT), argb_visual,
AllocNone);
}
depth = 32;
vis = argb_visual;
cmap = argb_cmap;
}
return ECreateWindowVDC(parent, x, y, w, h, vis, depth, cmap);
}
void
FocusScreen(int scr)
{
EX_Window xwin;
EX_Time t;
int x, y;
if (scr < 0 || scr >= ScreenCount(disp))
return;
/* IIRC warping to a different screen once did cause
* LeaveNotify's on the current root window. This does not
* happen in xorg 1.5.3 (and probably other versions).
* So, send LeaveNotify to current root and EnterNotify
* to new root. */
t = EGetTimestamp();
/* Report LeaveNotify on current root window */
xwin = WinGetXwin(VROOT);
EXQueryPointer(xwin, &x, &y, NULL, NULL);
_FocusScreenSendEvent(xwin, x, y, t, 0);
/* Do warp and report EnterNotify on new root window */
xwin = RootWindow(disp, scr);
x = DisplayWidth(disp, scr) / 2;
y = DisplayHeight(disp, scr) / 2;
EXWarpPointer(xwin, x, y);
_FocusScreenSendEvent(xwin, x, y, t, 1);
}
void
GrabKeyRelease(unsigned int keycode, unsigned int modifiers, Win win)
{
int i;
#if USE_XI2
XIGrabModifiers modifiers_inouts[8];
int num_modifiers;
if (modifiers == AnyModifier)
{
num_modifiers = 1;
modifiers_inouts[0].modifiers = XIAnyModifier;
modifiers_inouts[0].status = 0;
}
else
{
num_modifiers = 0;
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
modifiers_inouts[num_modifiers].modifiers =
modifiers | Mode.masks.mod_combos[i];
modifiers_inouts[num_modifiers].status = 0;
num_modifiers++;
}
}
XIUngrabKeycode(disp, DEV_KBD, keycode, WinGetXwin(win),
num_modifiers, modifiers_inouts);
#else
if (modifiers == AnyModifier)
{
XUngrabKey(disp, keycode, modifiers, WinGetXwin(win));
return;
}
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
XUngrabKey(disp, keycode, modifiers | Mode.masks.mod_combos[i],
WinGetXwin(win));
}
#endif
}
static void
ExtInitSS(int available)
{
if (!available)
return;
if (EDebug(EDBUG_TYPE_VERBOSE))
{
XScreenSaverInfo *xssi = XScreenSaverAllocInfo();
XScreenSaverQueryInfo(disp, WinGetXwin(VROOT), xssi);
Eprintf(" Screen saver window=%#lx\n", xssi->window);
XFree(xssi);
}
XScreenSaverSelectInput(disp, WinGetXwin(VROOT),
ScreenSaverNotifyMask | ScreenSaverCycleMask);
}
Bool
EQueryPointer(Win win, int *px, int *py, Window * pchild, unsigned int *pmask)
{
Window xwin;
xwin = (win) ? win->xwin : WinGetXwin(VROOT);
return EXQueryPointer(xwin, px, py, pchild, pmask);
}
void
GrabKeyRelease(unsigned int key, unsigned int modifiers, Win win)
{
int i;
if (modifiers == AnyModifier)
{
XUngrabKey(disp, key, modifiers, WinGetXwin(win));
return;
}
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
XUngrabKey(disp, key, modifiers | Mode.masks.mod_combos[i],
WinGetXwin(win));
}
}
void
HintsSetWindowClass(Win win, const char *name, const char *clss)
{
if (!name)
name = "NoName";
if (!clss)
clss = "NoClass";
ecore_x_icccm_name_class_set(WinGetXwin(win), name, clss);
}
Window
ExtInitWinCreate(void)
{
Ecore_X_Window win_ex; /* Hmmm.. */
Window win;
Atom a;
if (EDebug(EDBUG_TYPE_SESSION))
Eprintf("ExtInitWinCreate\n");
a = EInternAtom("ENLIGHTENMENT_RESTART_SCREEN");
ESync(0);
if (fork())
{
/* Parent */
EUngrabServer();
for (;;)
{
if (EDebug(EDBUG_TYPE_SESSION))
Eprintf("ExtInitWinCreate - parent\n");
/* Hack to give the child some space. Not foolproof. */
sleep(1);
if (ecore_x_window_prop_window_get
(WinGetXwin(VROOT), a, &win_ex, 1) > 0)
break;
}
win = win_ex;
if (EDebug(EDBUG_TYPE_SESSION))
Eprintf("ExtInitWinCreate - parent - %#lx\n", win);
return win;
}
/* Child - Create the init window */
if (EDebug(EDBUG_TYPE_SESSION))
Eprintf("ExtInitWinCreate - child\n");
/* Clean up inherited stuff */
SignalsRestore();
EImageExit(0);
EDisplayDisconnect();
ExtInitWinMain();
/* We will never get here */
return None;
}
/*
* Return index, -1 if not found.
*/
static int
SystrayObjFind(Container * ct, Window win)
{
int i;
for (i = 0; i < ct->num_objs; i++)
if (win == WinGetXwin(StObjGetWin(ct->objs[i].obj)))
return i;
return -1;
}
int
GrabPointerSet(Win win, unsigned int csr, int confine)
{
int ret;
Window confine_to = (confine) ? WinGetXwin(VROOT) : None;
ret = XGrabPointer(disp, WinGetXwin(win), False,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
ButtonMotionMask | EnterWindowMask | LeaveWindowMask,
GrabModeAsync, GrabModeAsync, confine_to, ECsrGet(csr),
CurrentTime);
Mode.grabs.pointer_grab_window = WinGetXwin(win);
Mode.grabs.pointer_grab_active = 1;
if (EDebug(EDBUG_TYPE_GRABS))
Eprintf("GrabPointerSet: %#lx, ret=%d\n", Mode.grabs.pointer_grab_window,
ret);
return ret;
}
static Win
ECreateWindowVD(Win parent, int x, int y, int w, int h,
Visual * vis, unsigned int depth)
{
Colormap cmap;
if (!vis || depth == 0)
return 0;
cmap = XCreateColormap(disp, WinGetXwin(VROOT), vis, AllocNone);
return ECreateWindowVDC(parent, x, y, w, h, vis, depth, cmap);
}
static int
SwitchRes(char inout, int x __UNUSED__, int y __UNUSED__, int w, int h,
int *dw, int *dh)
{
XRRScreenResources *xsr;
XRRCrtcInfo *xci;
RRCrtc crtc;
RRMode ss_mode_new;
int ok = 0;
Dprintf("%s: inout=%d\n", __func__, inout);
xsr = XRRGetScreenResourcesCurrent(disp, WinGetXwin(VROOT));
if (!xsr)
goto done;
crtc = xsr->crtcs[0]; /* FIXME - Which crtc? */
if (inout)
{
/* Save current setup */
xci = XRRGetCrtcInfo(disp, xsr, crtc);
if (!xci)
goto done;
ss_mode = xci->mode;
ss_rot = xci->rotation;
XRRFreeCrtcInfo(xci);
/* Select zoomed setup */
ss_mode_new = FindMode(xsr, w, h, dw, dh);
/* Set zoomed setup */
SetPanning(xsr, crtc, 1);
ok = SetMode(xsr, crtc, ss_mode_new, ss_rot);
}
else
{
/* Revert to original setup */
ok = SetMode(xsr, crtc, ss_mode, ss_rot);
SetPanning(xsr, crtc, 0);
}
done:
if (xsr)
XRRFreeScreenResources(xsr);
Dprintf("%s: ok=%d\n", __func__, ok);
return ok;
}
void
GrabKeySet(unsigned int key, unsigned int modifiers, Win win)
{
Bool owner_events = False;
int pointer_mode = GrabModeAsync;
int keyboard_mode = GrabModeSync;
int i;
if (modifiers == AnyModifier)
{
XGrabKey(disp, key, modifiers, WinGetXwin(win), owner_events,
pointer_mode, keyboard_mode);
return;
}
for (i = 0; i < 8; i++)
{
if (i && !Mode.masks.mod_combos[i])
continue;
XGrabKey(disp, key, modifiers | Mode.masks.mod_combos[i],
WinGetXwin(win), owner_events, pointer_mode, keyboard_mode);
}
}
static int
_GrabKeyboard(Win win, int sync_kbd)
{
int rc;
#if USE_XI2
EXIEventMask em;
EXIMaskSetup(&em, DEV_KBD, KeyPressMask | KeyReleaseMask);
rc = XIGrabDevice(disp, DEV_KBD, WinGetXwin(win), CurrentTime, NoXID,
GrabModeAsync, sync_kbd ? GrabModeSync : GrabModeAsync,
False, &em.em);
#else
rc = XGrabKeyboard(disp, WinGetXwin(win), False,
GrabModeAsync, sync_kbd ? GrabModeSync : GrabModeAsync,
CurrentTime);
#endif
#if 0
Eprintf("%s: %#lx sync=%d rc=%d\n", __func__, WinGetXwin(win), sync_kbd, rc);
#endif
return rc;
}
Bool
EXQueryPointer(Window xwin, int *px, int *py, Window * pchild,
unsigned int *pmask)
{
Window root, child;
int root_x, root_y;
unsigned int mask;
if (xwin == None)
xwin = WinGetXwin(VROOT);
if (!px)
px = &root_x;
if (!py)
py = &root_y;
if (!pchild)
pchild = &child;
if (!pmask)
pmask = &mask;
return XQueryPointer(disp, xwin, &root, pchild, &root_x, &root_y, px, py,
pmask);
}
int
EGetGeometry(Win win, Window * root_return, int *x, int *y,
int *w, int *h, int *bw, int *depth)
{
if (!win)
return 0;
if (x)
*x = win->x;
if (y)
*y = win->y;
if (w)
*w = win->w;
if (h)
*h = win->h;
if (bw)
*bw = 0;
if (depth)
*depth = win->depth;
if (root_return)
*root_return = WinGetXwin(VROOT);
return 1;
}
void
DrawEwinShape(EWin * ewin, int md, int x, int y, int w, int h,
int firstlast, int seqno)
{
ShapeData *psd;
int dx, dy;
/* Quit if no change */
if (firstlast == 1 &&
(x == ewin->shape_x && y == ewin->shape_y &&
(ewin->state.shaded || (w == ewin->shape_w && h == ewin->shape_h))))
return;
if ((md == MR_OPAQUE) || (md == MR_TECH_OPAQUE))
{
EwinOpMoveResize(ewin, OPSRC_USER, x, y, w, h);
EwinShapeSet(ewin);
CoordsShow(ewin);
if (md == MR_OPAQUE)
goto done;
}
if (firstlast == 0)
{
EwinShapeSet(ewin);
psd = ECALLOC(ShapeData, 1);
ewin->shape_data = psd;
if (!psd)
goto done;
psd->root = WinGetXwin(VROOT);
EwinBorderGetSize(ewin, &psd->bl, &psd->br, &psd->bt, &psd->bb);
}
psd = (ShapeData *) ewin->shape_data;
if (!psd)
goto done;
dx = EoGetX(EoGetDesk(ewin));
dy = EoGetY(EoGetDesk(ewin));
ewin->shape_x = x;
ewin->shape_y = y;
x += dx;
y += dy;
if (!ewin->state.shaded)
{
ewin->shape_w = w;
ewin->shape_h = h;
}
else
{
w = ewin->shape_w;
h = ewin->shape_h;
}
if (((md <= MR_BOX) || (md == MR_TECH_OPAQUE)) &&
Conf.movres.avoid_server_grab)
{
_ShapeDrawNograb_tech_box(ewin, md, firstlast, x, y, w, h, seqno);
goto done;
}
switch (md)
{
case MR_TECHNICAL:
case MR_TECH_OPAQUE:
case MR_BOX:
_ShapeDrawNontranslucent(ewin, md, firstlast, x, y, w, h);
break;
default:
/* Fall back to opaque mode */
Conf.movres.mode_move = MR_OPAQUE;
break;
}
psd->xo = x;
psd->yo = y;
psd->wo = w;
psd->ho = h;
done:
if (firstlast == 0 || firstlast == 2 || firstlast == 4)
{
ewin->req_x = ewin->shape_x;
ewin->req_y = ewin->shape_y;
if (firstlast == 2)
{
CoordsHide();
Efree(ewin->shape_data);
ewin->shape_data = NULL;
}
}
}
int
main(int argc, char **argv)
{
int ch, i, loop;
struct utsname ubuf;
const char *str, *dstr;
/* This function runs all the setup for startup, and then
* proceeds into the primary event loop at the end.
*/
/* Init state variable struct */
memset(&Mode, 0, sizeof(EMode));
Mode.wm.master = 1;
Mode.wm.pid = getpid();
Mode.wm.exec_name = argv[0];
Mode.wm.startup = 1;
Mode.mode = MODE_NONE;
EXInit();
Dpy.screen = -1;
str = getenv("EDEBUG");
if (str)
EDebugInit(str);
str = getenv("EDEBUG_COREDUMP");
if (str)
Mode.wm.coredump = 1;
str = getenv("EDEBUG_EXIT");
if (str)
Mode.debug_exit = atoi(str);
str = getenv("ECONFNAME");
if (str)
EConfNameSet(str);
str = getenv("ECONFDIR");
if (str)
EDirUserSet(str);
str = getenv("ECACHEDIR");
if (str)
EDirUserCacheSet(str);
srand((unsigned int)time(NULL));
if (!uname(&ubuf))
Mode.wm.machine_name = Estrdup(ubuf.nodename);
if (!Mode.wm.machine_name)
Mode.wm.machine_name = Estrdup("localhost");
/* Now we're going to interpret any of the commandline parameters
* that are passed to it -- Well, at least the ones that we
* understand.
*/
Mode.theme.path = NULL;
dstr = NULL;
for (loop = 1; loop;)
{
ch = EoptGet(argc, argv);
if (ch <= 0)
break;
#if 0
Eprintf("Opt: %c: %d - %s\n", ch, eoptind, eoptarg);
#endif
switch (ch)
{
default:
case '?':
printf("e16: Ignoring: ");
for (i = eoptind; i < argc; i++)
printf("%s ", argv[i]);
printf("\n");
loop = 0;
break;
case 'h':
EoptHelp();
exit(0);
break;
case 'd':
dstr = eoptarg;
break;
case 'f':
Mode.wm.restart = 1;
break;
case 'p':
EConfNameSet(eoptarg);
break;
case 'P':
EDirUserSet(eoptarg);
break;
case 'Q':
EDirUserCacheSet(eoptarg);
break;
case 's':
Mode.wm.single = 1;
Dpy.screen = strtoul(eoptarg, NULL, 10);
break;
case 'S':
SetSMID(eoptarg);
break;
case 't':
Mode.theme.path = Estrdup(eoptarg);
break;
case 'V':
printf("%s %s\n", e_wm_name, e_wm_version);
exit(0);
break;
case 'v':
EDebugSet(EDBUG_TYPE_VERBOSE, 1);
break;
case 'w':
sscanf(eoptarg, "%dx%d", &Mode.wm.win_w, &Mode.wm.win_h);
Mode.wm.window = 1;
Mode.wm.single = 1;
Mode.wm.master = 0;
break;
#ifdef USE_EXT_INIT_WIN
case 'X':
ExtInitWinSet(strtoul(eoptarg, NULL, 0));
Mode.wm.restart = 1;
break;
#endif
case 'm':
Mode.wm.master = 0;
Mode.wm.master_screen = strtoul(eoptarg, NULL, 10);
break;
}
}
SignalsSetup(); /* Install signal handlers */
EDirsSetup();
ECheckEprog("epp");
ECheckEprog("eesh");
SetupX(dstr); /* This is where the we fork per screen */
/* X is now running, and we have forked per screen */
ESavePrefixSetup();
/* So far nothing should rely on a selected settings or theme. */
ConfigurationLoad(); /* Load settings */
/* Initialise internationalisation */
LangInit();
/* The theme path must now be available for config file loading. */
ThemePathFind();
/* Set the Environment variables */
Esetenv("EVERSION", e_wm_version);
Esetenv("EROOT", EDirRoot());
Esetenv("EBIN", EDirBin());
Esetenv("ECONFDIR", EDirUser());
Esetenv("ECACHEDIR", EDirUserCache());
Esetenv("ETHEME", Mode.theme.path);
/* Move elsewhere? */
EImageInit();
HintsInit();
CommsInit();
SessionInit();
SnapshotsLoad();
#if USE_DBUS
DbusInit();
#endif
if (Mode.wm.window)
EMapWindow(VROOT);
ModulesSignal(ESIGNAL_INIT, NULL);
/* Load the theme */
ThemeConfigLoad();
if (Mode.debug_exit)
return 0;
/* Do initial configuration */
ModulesSignal(ESIGNAL_CONFIGURE, NULL);
/* Set root window cursor */
ECsrApply(ECSR_ROOT, WinGetXwin(VROOT));
#ifdef USE_EXT_INIT_WIN
/* Kill the E process owning the "init window" */
ExtInitWinKill();
#endif
/* let's make sure we set this up and go to our desk anyways */
DeskGoto(DesksGetCurrent());
ESync(ESYNC_MAIN);
#ifdef SIGCONT
for (i = 0; i < Mode.wm.child_count; i++)
kill(Mode.wm.children[i], SIGCONT);
#endif
ModulesSignal(ESIGNAL_START, NULL);
#if ENABLE_DIALOGS
DialogsInit();
#endif
EwinsManage();
RunInitPrograms();
SnapshotsSpawn();
if (!Mode.wm.restart)
StartupWindowsOpen();
Conf.startup.firsttime = 0;
Mode.wm.save_ok = Conf.autosave;
Mode.wm.startup = 0;
autosave();
/* The primary event loop */
EventsMain();
SessionExit(EEXIT_QUIT, NULL);
return 0;
}
