void W_BalloonHandleEnterView(WMView * view)
{
Balloon *bPtr = view->screen->balloon;
char *text;
if (!bPtr->flags.enabled)
return;
text = WMHashGet(bPtr->table, view);
if (!text) {
if (bPtr->view->flags.realized)
W_UnmapView(bPtr->view);
return;
}
if (bPtr->timer)
WMDeleteTimerHandler(bPtr->timer);
bPtr->timer = NULL;
if (bPtr->noDelayTimer)
WMDeleteTimerHandler(bPtr->noDelayTimer);
bPtr->noDelayTimer = NULL;
bPtr->forWindow = view->window;
if (bPtr->flags.noDelay) {
bPtr->timer = NULL;
showBalloon(view);
} else {
bPtr->timer = WMAddTimerHandler(bPtr->delay, showBalloon, view);
}
}
void W_DragSourceStopTimer()
{
if (dndSourceTimer != NULL) {
WMDeleteTimerHandler(dndSourceTimer);
dndSourceTimer = NULL;
}
}
static void destroyScroller(Scroller * sPtr)
{
/* we don't want autoscroll try to scroll a freed widget */
if (sPtr->timerID) {
WMDeleteTimerHandler(sPtr->timerID);
}
wfree(sPtr);
}
void wApplicationDestroy(WApplication * wapp)
{
WWindow *wwin;
WScreen *scr;
if (!wapp)
return;
wapp->refcount--;
if (wapp->refcount > 0)
return;
if (wapp->urgent_bounce_timer) {
WMDeleteTimerHandler(wapp->urgent_bounce_timer);
wapp->urgent_bounce_timer = NULL;
}
if (wapp->flags.bouncing) {
/* event.c:handleDestroyNotify forced this destroy
and thereby overlooked the bounce callback */
wapp->refcount = 1;
return;
}
scr = wapp->main_window_desc->screen_ptr;
if (wapp == scr->wapp_list) {
if (wapp->next)
wapp->next->prev = NULL;
scr->wapp_list = wapp->next;
} else {
if (wapp->next)
wapp->next->prev = wapp->prev;
if (wapp->prev)
wapp->prev->next = wapp->next;
}
XDeleteContext(dpy, wapp->main_window, wAppWinContext);
wAppMenuDestroy(wapp->menu);
/* Remove application icon */
removeAppIconFor(wapp);
wwin = wWindowFor(wapp->main_window_desc->client_win);
wWindowDestroy(wapp->main_window_desc);
if (wwin) {
/* undelete client window context that was deleted in
* wWindowDestroy */
XSaveContext(dpy, wwin->client_win, wWinContext, (XPointer) & wwin->client_descriptor);
}
wfree(wapp);
}
void wBalloonHide(WScreen *scr)
{
if (scr) {
if (scr->balloon->mapped) {
XUnmapWindow(dpy, scr->balloon->window);
scr->balloon->mapped = 0;
} else if (scr->balloon->timer) {
WMDeleteTimerHandler(scr->balloon->timer);
scr->balloon->timer = NULL;
}
scr->balloon->prevType = 0;
}
}
static void handleEvents(XEvent * event, void *data)
{
TextField *tPtr = (TextField *) data;
CHECK_CLASS(data, WC_TextField);
switch (event->type) {
case FocusIn:
W_FocusIC(tPtr->view);
if (W_FocusedViewOfToplevel(W_TopLevelOfView(tPtr->view)) != tPtr->view)
return;
tPtr->flags.focused = 1;
if (!tPtr->timerID) {
tPtr->timerID = WMAddTimerHandler(CURSOR_BLINK_ON_DELAY, blinkCursor, tPtr);
}
paintTextField(tPtr);
NOTIFY(tPtr, didBeginEditing, WMTextDidBeginEditingNotification, NULL);
tPtr->flags.notIllegalMovement = 0;
break;
case FocusOut:
W_UnFocusIC(tPtr->view);
tPtr->flags.focused = 0;
if (tPtr->timerID)
WMDeleteTimerHandler(tPtr->timerID);
tPtr->timerID = NULL;
paintTextField(tPtr);
if (!tPtr->flags.notIllegalMovement) {
NOTIFY(tPtr, didEndEditing, WMTextDidEndEditingNotification,
(void *)WMIllegalTextMovement);
}
break;
case Expose:
if (event->xexpose.count != 0)
break;
paintTextField(tPtr);
break;
case DestroyNotify:
destroyTextField(tPtr);
break;
}
}
void W_BalloonHandleLeaveView(WMView * view)
{
Balloon *bPtr = view->screen->balloon;
if (bPtr->forWindow == view->window) {
if (bPtr->view->flags.mapped) {
W_UnmapView(bPtr->view);
bPtr->noDelayTimer = WMAddTimerHandler(NO_DELAY_DELAY, clearNoDelay, bPtr);
}
if (bPtr->timer)
WMDeleteTimerHandler(bPtr->timer);
bPtr->timer = NULL;
bPtr->forWindow = None;
}
}
static void destroyTextField(TextField * tPtr)
{
if (tPtr->timerID)
WMDeleteTimerHandler(tPtr->timerID);
W_DestroyIC(tPtr->view);
WMReleaseFont(tPtr->font);
/*// use lostSelection() instead of WMDeleteSelectionHandler here? */
WMDeleteSelectionHandler(tPtr->view, XA_PRIMARY, CurrentTime);
WMRemoveNotificationObserver(tPtr);
if (tPtr->text)
wfree(tPtr->text);
wfree(tPtr);
}
void wBalloonEnteredObject(WScreen *scr, WObjDescriptor *object)
{
WBalloon *balloon = scr->balloon;
if (balloon->timer) {
WMDeleteTimerHandler(balloon->timer);
balloon->timer = NULL;
balloon->ignoreTimer = 0;
}
if (scr->balloon->text)
wfree(scr->balloon->text);
scr->balloon->text = NULL;
scr->balloon->apercu = None;
if (!object) {
wBalloonHide(scr);
balloon->ignoreTimer = 0;
return;
}
switch (object->parent_type) {
case WCLASS_FRAME:
if (wPreferences.window_balloon)
frameBalloon(object);
break;
case WCLASS_DOCK_ICON:
if (wPreferences.appicon_balloon)
appiconBalloon(object);
break;
case WCLASS_MINIWINDOW:
if (wPreferences.miniwin_title_balloon || wPreferences.miniwin_apercu_balloon)
miniwindowBalloon(object);
break;
case WCLASS_APPICON:
if (wPreferences.appicon_balloon)
appiconBalloon(object);
break;
default:
wBalloonHide(scr);
break;
}
scr->balloon->prevType = object->parent_type;
}
static char *getTextSelection(WScreen * screen, Atom selection)
{
int buffer = -1;
switch (selection) {
case XA_CUT_BUFFER0:
buffer = 0;
break;
case XA_CUT_BUFFER1:
buffer = 1;
break;
case XA_CUT_BUFFER2:
buffer = 2;
break;
case XA_CUT_BUFFER3:
buffer = 3;
break;
case XA_CUT_BUFFER4:
buffer = 4;
break;
case XA_CUT_BUFFER5:
buffer = 5;
break;
case XA_CUT_BUFFER6:
buffer = 6;
break;
case XA_CUT_BUFFER7:
buffer = 7;
break;
}
if (buffer >= 0) {
char *data;
int size;
data = XFetchBuffer(dpy, &size, buffer);
return data;
} else {
char *data;
int bits;
Atom rtype;
unsigned long len, bytes;
WMHandlerID timer;
int timeout = 0;
XEvent ev;
static Atom clipboard = 0;
if (!clipboard)
clipboard = XInternAtom(dpy, "CLIPBOARD", False);
XDeleteProperty(dpy, screen->info_window, clipboard);
XConvertSelection(dpy, selection, XA_STRING, clipboard, screen->info_window, CurrentTime);
timer = WMAddTimerHandler(1000, timeoutHandler, &timeout);
while (!XCheckTypedWindowEvent(dpy, screen->info_window, SelectionNotify, &ev) && !timeout) ;
if (!timeout) {
WMDeleteTimerHandler(timer);
} else {
wwarning("selection retrieval timed out");
return NULL;
}
/* nobody owns the selection or the current owner has
* nothing to do with what we need */
if (ev.xselection.property == None) {
return NULL;
}
if (XGetWindowProperty(dpy, screen->info_window,
clipboard, 0, 1024,
False, XA_STRING, &rtype, &bits, &len,
&bytes, (unsigned char **)&data) != Success) {
return NULL;
}
if (rtype != XA_STRING || bits != 8) {
wwarning("invalid data in text selection");
if (data)
XFree(data);
return NULL;
}
return data;
}
}
static void showWorkspaceName(WScreen * scr, int workspace)
{
WorkspaceNameData *data;
RXImage *ximg;
Pixmap text, mask;
int w, h;
int px, py;
char *name = w_global.workspace.array[workspace]->name;
int len = strlen(name);
int x, y;
#ifdef USE_XINERAMA
int head;
WMRect rect;
int xx, yy;
#endif
if (wPreferences.workspace_name_display_position == WD_NONE || w_global.workspace.count < 2)
return;
if (scr->workspace_name_timer) {
WMDeleteTimerHandler(scr->workspace_name_timer);
XUnmapWindow(dpy, scr->workspace_name);
XFlush(dpy);
}
scr->workspace_name_timer = WMAddTimerHandler(WORKSPACE_NAME_DELAY, hideWorkspaceName, scr);
if (scr->workspace_name_data) {
RReleaseImage(scr->workspace_name_data->back);
RReleaseImage(scr->workspace_name_data->text);
wfree(scr->workspace_name_data);
}
data = wmalloc(sizeof(WorkspaceNameData));
data->back = NULL;
w = WMWidthOfString(w_global.workspace.font_for_name, name, len);
h = WMFontHeight(w_global.workspace.font_for_name);
#ifdef USE_XINERAMA
head = wGetHeadForPointerLocation(scr);
rect = wGetRectForHead(scr, head);
if (scr->xine_info.count) {
xx = rect.pos.x + (scr->xine_info.screens[head].size.width - (w + 4)) / 2;
yy = rect.pos.y + (scr->xine_info.screens[head].size.height - (h + 4)) / 2;
}
else {
xx = (scr->scr_width - (w + 4)) / 2;
yy = (scr->scr_height - (h + 4)) / 2;
}
#endif
switch (wPreferences.workspace_name_display_position) {
case WD_TOP:
#ifdef USE_XINERAMA
px = xx;
#else
px = (scr->scr_width - (w + 4)) / 2;
#endif
py = WORKSPACE_NAME_DISPLAY_PADDING;
break;
case WD_BOTTOM:
#ifdef USE_XINERAMA
px = xx;
#else
px = (scr->scr_width - (w + 4)) / 2;
#endif
py = scr->scr_height - (h + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
break;
case WD_TOPLEFT:
px = WORKSPACE_NAME_DISPLAY_PADDING;
py = WORKSPACE_NAME_DISPLAY_PADDING;
break;
case WD_TOPRIGHT:
px = scr->scr_width - (w + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
py = WORKSPACE_NAME_DISPLAY_PADDING;
break;
case WD_BOTTOMLEFT:
px = WORKSPACE_NAME_DISPLAY_PADDING;
py = scr->scr_height - (h + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
break;
case WD_BOTTOMRIGHT:
px = scr->scr_width - (w + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
py = scr->scr_height - (h + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
break;
case WD_CENTER:
default:
#ifdef USE_XINERAMA
px = xx;
py = yy;
#else
px = (scr->scr_width - (w + 4)) / 2;
py = (scr->scr_height - (h + 4)) / 2;
#endif
break;
}
XResizeWindow(dpy, scr->workspace_name, w + 4, h + 4);
XMoveWindow(dpy, scr->workspace_name, px, py);
text = XCreatePixmap(dpy, scr->w_win, w + 4, h + 4, scr->w_depth);
mask = XCreatePixmap(dpy, scr->w_win, w + 4, h + 4, 1);
/*XSetForeground(dpy, scr->mono_gc, 0);
XFillRectangle(dpy, mask, scr->mono_gc, 0, 0, w+4, h+4); */
XFillRectangle(dpy, text, WMColorGC(scr->black), 0, 0, w + 4, h + 4);
for (x = 0; x <= 4; x++)
for (y = 0; y <= 4; y++)
WMDrawString(scr->wmscreen, text, scr->white, w_global.workspace.font_for_name, x, y, name, len);
XSetForeground(dpy, scr->mono_gc, 1);
XSetBackground(dpy, scr->mono_gc, 0);
XCopyPlane(dpy, text, mask, scr->mono_gc, 0, 0, w + 4, h + 4, 0, 0, 1 << (scr->w_depth - 1));
/*XSetForeground(dpy, scr->mono_gc, 1); */
XSetBackground(dpy, scr->mono_gc, 1);
XFillRectangle(dpy, text, WMColorGC(scr->black), 0, 0, w + 4, h + 4);
WMDrawString(scr->wmscreen, text, scr->white, w_global.workspace.font_for_name, 2, 2, name, len);
#ifdef USE_XSHAPE
if (w_global.xext.shape.supported)
XShapeCombineMask(dpy, scr->workspace_name, ShapeBounding, 0, 0, mask, ShapeSet);
#endif
XSetWindowBackgroundPixmap(dpy, scr->workspace_name, text);
XClearWindow(dpy, scr->workspace_name);
data->text = RCreateImageFromDrawable(scr->rcontext, text, None);
XFreePixmap(dpy, text);
XFreePixmap(dpy, mask);
if (!data->text) {
XMapRaised(dpy, scr->workspace_name);
XFlush(dpy);
goto erro;
}
ximg = RGetXImage(scr->rcontext, scr->root_win, px, py, data->text->width, data->text->height);
if (!ximg || !ximg->image) {
goto erro;
}
XMapRaised(dpy, scr->workspace_name);
XFlush(dpy);
data->back = RCreateImageFromXImage(scr->rcontext, ximg->image, NULL);
RDestroyXImage(scr->rcontext, ximg);
if (!data->back) {
goto erro;
}
data->count = 10;
/* set a timeout for the effect */
data->timeout = time(NULL) + 2 + (WORKSPACE_NAME_DELAY + WORKSPACE_NAME_FADE_DELAY * data->count) / 1000;
scr->workspace_name_data = data;
return;
erro:
if (scr->workspace_name_timer)
WMDeleteTimerHandler(scr->workspace_name_timer);
if (data->text)
RReleaseImage(data->text);
if (data->back)
RReleaseImage(data->back);
wfree(data);
scr->workspace_name_data = NULL;
scr->workspace_name_timer = WMAddTimerHandler(WORKSPACE_NAME_DELAY +
10 * WORKSPACE_NAME_FADE_DELAY, hideWorkspaceName, scr);
}
static void handleActionEvents(XEvent * event, void *data)
{
Scroller *sPtr = (Scroller *) data;
int wheelDecrement, wheelIncrement;
int id, dd;
/* check if we're really dealing with a scroller, as something
* might have gone wrong in the event dispatching stuff */
CHECK_CLASS(sPtr, WC_Scroller);
id = sPtr->flags.incrDown;
dd = sPtr->flags.decrDown;
switch (event->type) {
case EnterNotify:
break;
case LeaveNotify:
if (sPtr->timerID) {
WMDeleteTimerHandler(sPtr->timerID);
sPtr->timerID = NULL;
}
sPtr->flags.incrDown = 0;
sPtr->flags.decrDown = 0;
break;
case ButtonPress:
/* FIXME: change Mod1Mask with something else */
if (sPtr->flags.documentFullyVisible)
break;
if (sPtr->flags.horizontal) {
wheelDecrement = WINGsConfiguration.mouseWheelDown;
wheelIncrement = WINGsConfiguration.mouseWheelUp;
} else {
wheelDecrement = WINGsConfiguration.mouseWheelUp;
wheelIncrement = WINGsConfiguration.mouseWheelDown;
}
if (event->xbutton.button == wheelDecrement) {
if (event->xbutton.state & ControlMask) {
sPtr->flags.hitPart = WSDecrementPage;
} else if (event->xbutton.state & ShiftMask) {
sPtr->flags.hitPart = WSDecrementLine;
} else {
sPtr->flags.hitPart = WSDecrementWheel;
}
if (sPtr->action) {
(*sPtr->action) (sPtr, sPtr->clientData);
WMPostNotificationName(WMScrollerDidScrollNotification, sPtr, NULL);
}
} else if (event->xbutton.button == wheelIncrement) {
if (event->xbutton.state & ControlMask) {
sPtr->flags.hitPart = WSIncrementPage;
} else if (event->xbutton.state & ShiftMask) {
sPtr->flags.hitPart = WSIncrementLine;
} else {
sPtr->flags.hitPart = WSIncrementWheel;
}
if (sPtr->action) {
(*sPtr->action) (sPtr, sPtr->clientData);
WMPostNotificationName(WMScrollerDidScrollNotification, sPtr, NULL);
}
} else {
handlePush(sPtr, event->xbutton.x, event->xbutton.y, (event->xbutton.state & Mod1Mask)
|| event->xbutton.button == Button2);
/* continue scrolling if pushed on the buttons */
if (sPtr->flags.hitPart == WSIncrementLine || sPtr->flags.hitPart == WSDecrementLine) {
sPtr->timerID = WMAddTimerHandler(AUTOSCROLL_INITIAL_DELAY, autoScroll, sPtr);
}
}
break;
case ButtonRelease:
if (sPtr->flags.draggingKnob) {
if (sPtr->action) {
(*sPtr->action) (sPtr, sPtr->clientData);
WMPostNotificationName(WMScrollerDidScrollNotification, sPtr, NULL);
}
}
if (sPtr->timerID) {
WMDeleteTimerHandler(sPtr->timerID);
sPtr->timerID = NULL;
}
sPtr->flags.incrDown = 0;
sPtr->flags.decrDown = 0;
sPtr->flags.draggingKnob = 0;
break;
case MotionNotify:
handleMotion(sPtr, event->xbutton.x, event->xbutton.y);
if (sPtr->timerID && sPtr->flags.hitPart != WSIncrementLine
&& sPtr->flags.hitPart != WSDecrementLine) {
WMDeleteTimerHandler(sPtr->timerID);
sPtr->timerID = NULL;
}
break;
}
if (id != sPtr->flags.incrDown || dd != sPtr->flags.decrDown)
paintScroller(sPtr);
}
