gryf/wmaker
1
0
Fork 0
mirror of https://github.com/gryf/wmaker.git synced 2025-12-19 12:28:22 +01:00
Code Issues Projects Releases Wiki Activity
Files
c8b3933c19afea75abeb0e6ba2bd1644ba5462e2
wmaker/src/dock.c
dan c8b3933c19 - Fixed xmms problem with shared appicons 
- Fixed a problem with saving user defaults for windows after the shared
  appicon changes.
- Fixed GNUstep apps not to show 2 appicons.
2001-12-18 05:18:35 +00:00

4478 lines
116 KiB
C
Raw Blame History

/* dock.c- built-in Dock module for WindowMaker
*
* Window Maker window manager
*
* Copyright (c) 1997, 1998 Alfredo K. Kojima
* Copyright (c) 1998, 1999 Dan Pascu
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
* USA.
*/
#include "wconfig.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
#include <limits.h>
#ifndef PATH_MAX
#define PATH_MAX DEFAULT_PATH_MAX
#endif
#include "WindowMaker.h"
#include "wcore.h"
#include "window.h"
#include "icon.h"
#include "appicon.h"
#include "actions.h"
#include "stacking.h"
#include "dock.h"
#include "dialog.h"
#include "funcs.h"
#include "properties.h"
#include "menu.h"
#include "client.h"
#include "defaults.h"
#include "workspace.h"
#include "framewin.h"
#include "superfluous.h"
#include "wsound.h"
#include <WINGs/WUtil.h>
/**** Local variables ****/
#define CLIP_REWIND 1
#define CLIP_IDLE 0
#define CLIP_FORWARD 2
/**** Global variables ****/
/* in dockedapp.c */
extern void DestroyDockAppSettingsPanel();
extern void ShowDockAppSettingsPanel(WAppIcon *aicon);
extern XContext wWinContext;
extern Cursor wCursor[WCUR_LAST];
extern WPreferences wPreferences;
extern XContext wWinContext;
#ifdef OFFIX_DND
extern Atom _XA_DND_PROTOCOL;
#endif
#define MOD_MASK wPreferences.modifier_mask
extern void appIconMouseDown(WObjDescriptor *desc, XEvent *event);
#define ICON_SIZE wPreferences.icon_size
/***** Local variables ****/
static WMPropList *dCommand=NULL;
static WMPropList *dPasteCommand=NULL;
#ifdef OFFIX_DND
static WMPropList *dDropCommand=NULL;
#endif
static WMPropList *dAutoLaunch, *dLock;
static WMPropList *dName, *dForced, *dBuggyApplication, *dYes, *dNo;
static WMPropList *dHost, *dDock, *dClip;
static WMPropList *dAutoAttractIcons;
static WMPropList *dPosition, *dApplications, *dLowered, *dCollapsed;
static WMPropList *dAutoCollapse, *dAutoRaiseLower, *dOmnipresent;
static void dockIconPaint(WAppIcon *btn);
static void iconMouseDown(WObjDescriptor *desc, XEvent *event);
static pid_t execCommand(WAppIcon *btn, char *command, WSavedState *state);
static void trackDeadProcess(pid_t pid, unsigned char status, WDock *dock);
static int getClipButton(int px, int py);
static void toggleLowered(WDock *dock);
static void toggleCollapsed(WDock *dock);
static void clipIconExpose(WObjDescriptor *desc, XEvent *event);
static void clipLeave(WDock *dock);
static void handleClipChangeWorkspace(WScreen *scr, XEvent *event);
Bool moveIconBetweenDocks(WDock *src, WDock *dest, WAppIcon *icon, int x, int y);
static void clipEnterNotify(WObjDescriptor *desc, XEvent *event);
static void clipLeaveNotify(WObjDescriptor *desc, XEvent *event);
static void clipAutoCollapse(void *cdata);
static void clipAutoExpand(void *cdata);
static void launchDockedApplication(WAppIcon *btn, Bool withSelection);
static void clipAutoLower(void *cdata);
static void clipAutoRaise(void *cdata);
static void showClipBalloon(WDock *dock, int workspace);
#ifdef OFFIX_DND
#define DndNotDnd -1
#define DndUnknown 0
#define DndRawData 1
#define DndFile 2
#define DndFiles 3
#define DndText 4
#define DndDir 5
#define DndLink 6
#define DndExe 7
#define DndEND 8
#endif /* OFFIX_DND */
static void
make_keys()
{
if (dCommand!=NULL)
return;
dCommand = WMRetainPropList(WMCreatePLString("Command"));
dPasteCommand = WMRetainPropList(WMCreatePLString("PasteCommand"));
dDropCommand = WMRetainPropList(WMCreatePLString("DropCommand"));
dLock = WMRetainPropList(WMCreatePLString("Lock"));
dAutoLaunch = WMRetainPropList(WMCreatePLString("AutoLaunch"));
dName = WMRetainPropList(WMCreatePLString("Name"));
dForced = WMRetainPropList(WMCreatePLString("Forced"));
dBuggyApplication = WMRetainPropList(WMCreatePLString("BuggyApplication"));
dYes = WMRetainPropList(WMCreatePLString("Yes"));
dNo = WMRetainPropList(WMCreatePLString("No"));
dHost = WMRetainPropList(WMCreatePLString("Host"));
dPosition = WMCreatePLString("Position");
dApplications = WMCreatePLString("Applications");
dLowered = WMCreatePLString("Lowered");
dCollapsed = WMCreatePLString("Collapsed");
dAutoCollapse = WMCreatePLString("AutoCollapse");
dAutoRaiseLower = WMCreatePLString("AutoRaiseLower");
dAutoAttractIcons = WMCreatePLString("AutoAttractIcons");
dOmnipresent = WMCreatePLString("Omnipresent");
dDock = WMCreatePLString("Dock");
dClip = WMCreatePLString("Clip");
}
static void
renameCallback(WMenu *menu, WMenuEntry *entry)
{
WDock *dock = entry->clientdata;
char buffer[128];
int wspace;
char *name;
assert(entry->clientdata!=NULL);
wspace = dock->screen_ptr->current_workspace;
name = wstrdup(dock->screen_ptr->workspaces[wspace]->name);
snprintf(buffer, sizeof(buffer), _("Type the name for workspace %i:"), wspace+1);
if (wInputDialog(dock->screen_ptr, _("Rename Workspace"), buffer,
&name)) {
wWorkspaceRename(dock->screen_ptr, wspace, name);
}
if (name) {
wfree(name);
}
}
static void
toggleLoweredCallback(WMenu *menu, WMenuEntry *entry)
{
assert(entry->clientdata!=NULL);
toggleLowered(entry->clientdata);
entry->flags.indicator_on = !(((WDock*)entry->clientdata)->lowered);
wMenuPaint(menu);
}
static int
matchWindow(void *item, void *cdata)
{
return (((WFakeGroupLeader*)item)->leader == (Window)cdata);
}
static void
killCallback(WMenu *menu, WMenuEntry *entry)
{
WScreen *scr = menu->menu->screen_ptr;
WAppIcon *icon;
WFakeGroupLeader *fPtr;
char *buffer;
if (!WCHECK_STATE(WSTATE_NORMAL))
return;
assert(entry->clientdata!=NULL);
icon = (WAppIcon*)entry->clientdata;
icon->editing = 1;
WCHANGE_STATE(WSTATE_MODAL);
buffer = wstrconcat(icon->wm_class,
_(" will be forcibly closed.\n"
"Any unsaved changes will be lost.\n"
"Please confirm."));
if (icon->icon && icon->icon->owner) {
fPtr = icon->icon->owner->fake_group;
} else {
/* is this really necessary? can we kill a dock icon not running? */
Window win = icon->main_window;
int index;
index = WMFindInArray(scr->fakeGroupLeaders, matchWindow, (void*)win);
if (index != WANotFound)
fPtr = WMGetFromArray(scr->fakeGroupLeaders, index);
else
fPtr = NULL;
}
if (wPreferences.dont_confirm_kill
|| wMessageDialog(menu->frame->screen_ptr, _("Kill Application"),
buffer, _("Yes"), _("No"), NULL)==WAPRDefault) {
if (fPtr!=NULL) {
WWindow *wwin, *twin;
wwin = scr->focused_window;
while (wwin) {
twin = wwin->prev;
if (wwin->fake_group == fPtr) {
wClientKill(wwin);
}
wwin = twin;
}
} else if (icon->icon && icon->icon->owner) {
wClientKill(icon->icon->owner);
}
}
wfree(buffer);
icon->editing = 0;
WCHANGE_STATE(WSTATE_NORMAL);
}
/* TODO: replace this function with a member of the dock struct */
static int
numberOfSelectedIcons(WDock *dock)
{
WAppIcon *aicon;
int i, n;
n = 0;
for (i=1; i<dock->max_icons; i++) {
aicon = dock->icon_array[i];
if (aicon && aicon->icon->selected) {
n++;
}
}
return n;
}
static WMArray*
getSelected(WDock *dock)
{
WMArray *ret = WMCreateArray(8);
WAppIcon *btn;
int i;
for (i=1; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (btn && btn->icon->selected) {
WMAddToArray(ret, btn);
}
}
return ret;
}
static void
paintClipButtons(WAppIcon *clipIcon, Bool lpushed, Bool rpushed)
{
Window win = clipIcon->icon->core->window;
WScreen *scr = clipIcon->icon->core->screen_ptr;
XPoint p[4];
int pt = CLIP_BUTTON_SIZE*ICON_SIZE/64;
int tp = ICON_SIZE - pt;
int as = pt - 15; /* 15 = 5+5+5 */
GC gc = scr->clip_title_gc;
#ifdef GRADIENT_CLIP_ARROW
Bool collapsed = clipIcon->dock->collapsed;
#endif
if (rpushed) {
p[0].x = tp+1;
p[0].y = 1;
p[1].x = ICON_SIZE-2;
p[1].y = 1;
p[2].x = ICON_SIZE-2;
p[2].y = pt-1;
} else if (lpushed) {
p[0].x = 1;
p[0].y = tp;
p[1].x = pt;
p[1].y = ICON_SIZE-2;
p[2].x = 1;
p[2].y = ICON_SIZE-2;
}
if (lpushed || rpushed) {
XSetForeground(dpy, scr->draw_gc, scr->white_pixel);
XFillPolygon(dpy, win, scr->draw_gc, p, 3, Convex, CoordModeOrigin);
XSetForeground(dpy, scr->draw_gc, scr->black_pixel);
}
#ifdef GRADIENT_CLIP_ARROW
if (!collapsed) {
XSetFillStyle(dpy, scr->copy_gc, FillTiled);
XSetTile(dpy, scr->copy_gc, scr->clip_arrow_gradient);
XSetClipMask(dpy, scr->copy_gc, None);
gc = scr->copy_gc;
}
#endif /* GRADIENT_CLIP_ARROW */
/* top right arrow */
p[0].x = p[3].x = ICON_SIZE-5-as;
p[0].y = p[3].y = 5;
p[1].x = ICON_SIZE-6;
p[1].y = 5;
p[2].x = ICON_SIZE-6;
p[2].y = 4+as;
if (rpushed) {
XFillPolygon(dpy, win, scr->draw_gc, p, 3, Convex, CoordModeOrigin);
XDrawLines(dpy, win, scr->draw_gc, p, 4, CoordModeOrigin);
} else {
#ifdef GRADIENT_CLIP_ARROW
if (!collapsed)
XSetTSOrigin(dpy, gc, ICON_SIZE-6-as, 5);
#endif
XFillPolygon(dpy, win, gc, p,3,Convex,CoordModeOrigin);
XDrawLines(dpy, win, gc, p,4,CoordModeOrigin);
}
/* bottom left arrow */
p[0].x = p[3].x = 5;
p[0].y = p[3].y = ICON_SIZE-5-as;
p[1].x = 5;
p[1].y = ICON_SIZE-6;
p[2].x = 4+as;
p[2].y = ICON_SIZE-6;
if (lpushed) {
XFillPolygon(dpy, win, scr->draw_gc, p, 3, Convex, CoordModeOrigin);
XDrawLines(dpy, win, scr->draw_gc, p, 4, CoordModeOrigin);
} else {
#ifdef GRADIENT_CLIP_ARROW
if (!collapsed)
XSetTSOrigin(dpy, gc, 5, ICON_SIZE-6-as);
#endif
XFillPolygon(dpy, win, gc, p,3,Convex,CoordModeOrigin);
XDrawLines(dpy, win, gc, p,4,CoordModeOrigin);
}
#ifdef GRADIENT_CLIP_ARROW
if (!collapsed)
XSetFillStyle(dpy, scr->copy_gc, FillSolid);
#endif
}
RImage*
wClipMakeTile(WScreen *scr, RImage *normalTile)
{
RImage *tile = RCloneImage(normalTile);
RColor black;
RColor dark;
RColor light;
int pt, tp;
int as;
pt = CLIP_BUTTON_SIZE*wPreferences.icon_size/64;
tp = wPreferences.icon_size-1 - pt;
as = pt - 15;
black.alpha = 255;
black.red = black.green = black.blue = 0;
dark.alpha = 0;
dark.red = dark.green = dark.blue = 60;
light.alpha = 0;
light.red = light.green = light.blue = 80;
/* top right */
ROperateLine(tile, RSubtractOperation, tp, 0, wPreferences.icon_size-2,
pt-1, &dark);
RDrawLine(tile, tp-1, 0, wPreferences.icon_size-1, pt+1, &black);
ROperateLine(tile, RAddOperation, tp, 2, wPreferences.icon_size-3,
pt, &light);
/* arrow bevel */
ROperateLine(tile, RSubtractOperation, ICON_SIZE - 7 - as, 4,
ICON_SIZE - 5, 4, &dark);
ROperateLine(tile, RSubtractOperation, ICON_SIZE - 6 - as, 5,
ICON_SIZE - 5, 6 + as, &dark);
ROperateLine(tile, RAddOperation, ICON_SIZE - 5, 4, ICON_SIZE - 5, 6 + as,
&light);
/* bottom left */
ROperateLine(tile, RAddOperation, 2, tp+2, pt-2,
wPreferences.icon_size-3, &dark);
RDrawLine(tile, 0, tp-1, pt+1, wPreferences.icon_size-1, &black);
ROperateLine(tile, RSubtractOperation, 0, tp-2, pt+1,
wPreferences.icon_size-2, &light);
/* arrow bevel */
ROperateLine(tile, RSubtractOperation, 4, ICON_SIZE - 7 - as, 4,
ICON_SIZE - 5, &dark);
ROperateLine(tile, RSubtractOperation, 5, ICON_SIZE - 6 - as,
6 + as, ICON_SIZE - 5, &dark);
ROperateLine(tile, RAddOperation, 4, ICON_SIZE - 5, 6 + as, ICON_SIZE - 5,
&light);
return tile;
}
static void
omnipresentCallback(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *clickedIcon = entry->clientdata;
WAppIcon *aicon;
WDock *dock;
WMArray *selectedIcons;
WMArrayIterator iter;
int failed;
assert(entry->clientdata!=NULL);
dock = clickedIcon->dock;
selectedIcons = getSelected(dock);
if (!WMGetArrayItemCount(selectedIcons))
WMAddToArray(selectedIcons, clickedIcon);
failed = 0;
WM_ITERATE_ARRAY(selectedIcons, aicon, iter) {
if (wClipMakeIconOmnipresent(aicon, !aicon->omnipresent) == WO_FAILED)
failed++;
else if (aicon->icon->selected)
wIconSelect(aicon->icon);
}
WMFreeArray(selectedIcons);
if (failed > 1) {
wMessageDialog(dock->screen_ptr, _("Warning"),
_("Some icons cannot be made omnipresent. "
"Please make sure that no other icon is "
"docked in the same positions on the other "
"workspaces and the Clip is not full in "
"some workspace."),
_("OK"), NULL, NULL);
} else if (failed == 1) {
wMessageDialog(dock->screen_ptr, _("Warning"),
_("Icon cannot be made omnipresent. "
"Please make sure that no other icon is "
"docked in the same position on the other "
"workspaces and the Clip is not full in "
"some workspace."),
_("OK"), NULL, NULL);
}
}
static void
removeIconsCallback(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *clickedIcon = (WAppIcon*)entry->clientdata;
WDock *dock;
WAppIcon *aicon;
WMArray *selectedIcons;
int keepit;
WMArrayIterator it;
assert(clickedIcon!=NULL);
dock = clickedIcon->dock;
selectedIcons = getSelected(dock);
if (WMGetArrayItemCount(selectedIcons)) {
if (wMessageDialog(dock->screen_ptr, _("Workspace Clip"),
_("All selected icons will be removed!"),
_("OK"), _("Cancel"), NULL)!=WAPRDefault) {
WMFreeArray(selectedIcons);
return;
}
} else {
if (clickedIcon->xindex==0 && clickedIcon->yindex==0) {
WMFreeArray(selectedIcons);
return;
}
WMAddToArray(selectedIcons, clickedIcon);
}
WM_ITERATE_ARRAY(selectedIcons, aicon, it) {
keepit = aicon->running && wApplicationOf(aicon->main_window);
wDockDetach(dock, aicon);
if (keepit) {
PlaceIcon(dock->screen_ptr, &aicon->x_pos, &aicon->y_pos);
XMoveWindow(dpy, aicon->icon->core->window,
aicon->x_pos, aicon->y_pos);
if (!dock->mapped || dock->collapsed)
XMapWindow(dpy, aicon->icon->core->window);
}
}
WMFreeArray(selectedIcons);
if (wPreferences.auto_arrange_icons)
wArrangeIcons(dock->screen_ptr, True);
}
static void
keepIconsCallback(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *clickedIcon = (WAppIcon*)entry->clientdata;
WDock *dock;
WAppIcon *aicon;
WMArray *selectedIcons;
WMArrayIterator it;
assert(clickedIcon!=NULL);
dock = clickedIcon->dock;
selectedIcons = getSelected(dock);
if (!WMGetArrayItemCount(selectedIcons)
&& clickedIcon!=dock->screen_ptr->clip_icon) {
char *command = NULL;
if (!clickedIcon->command && !clickedIcon->editing) {
clickedIcon->editing = 1;
if (wInputDialog(dock->screen_ptr, _("Keep Icon"),
_("Type the command used to launch the application"),
&command)) {
if (command && (command[0]==0 ||
(command[0]=='-' && command[1]==0))) {
wfree(command);
command = NULL;
}
clickedIcon->command = command;
clickedIcon->editing = 0;
} else {
clickedIcon->editing = 0;
if (command)
wfree(command);
WMFreeArray(selectedIcons);
return;
}
}
WMAddToArray(selectedIcons, clickedIcon);
}
WM_ITERATE_ARRAY(selectedIcons, aicon, it) {
if (aicon->icon->selected)
wIconSelect(aicon->icon);
if (aicon && aicon->attracted && aicon->command) {
aicon->attracted = 0;
if (aicon->icon->shadowed) {
aicon->icon->shadowed = 0;
aicon->icon->force_paint = 1;
wAppIconPaint(aicon);
}
}
}
WMFreeArray(selectedIcons);
}
static void
toggleAutoAttractCallback(WMenu *menu, WMenuEntry *entry)
{
WDock *dock = (WDock*)entry->clientdata;
assert(entry->clientdata!=NULL);
dock->attract_icons = !dock->attract_icons;
/*if (!dock->attract_icons)
dock->keep_attracted = 0;*/
entry->flags.indicator_on = dock->attract_icons;
wMenuPaint(menu);
}
static void
selectCallback(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *icon = (WAppIcon*)entry->clientdata;
assert(icon!=NULL);
wIconSelect(icon->icon);
wMenuPaint(menu);
}
static void
colectIconsCallback(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *clickedIcon = (WAppIcon*)entry->clientdata;
WDock *clip;
WAppIcon *aicon;
int x, y, x_pos, y_pos;
assert(entry->clientdata!=NULL);
clip = clickedIcon->dock;
aicon = clip->screen_ptr->app_icon_list;
while (aicon) {
if (!aicon->docked && wDockFindFreeSlot(clip, &x, &y)) {
x_pos = clip->x_pos + x*ICON_SIZE;
y_pos = clip->y_pos + y*ICON_SIZE;
if (aicon->x_pos != x_pos || aicon->y_pos != y_pos) {
#ifdef ANIMATIONS
if (wPreferences.no_animations) {
XMoveWindow(dpy, aicon->icon->core->window, x_pos, y_pos);
} else {
SlideWindow(aicon->icon->core->window,
aicon->x_pos, aicon->y_pos, x_pos, y_pos);
}
#else
XMoveWindow(dpy, aicon->icon->core->window, x_pos, y_pos);
#endif /* ANIMATIONS */
}
aicon->attracted = 1;
if (!aicon->icon->shadowed) {
aicon->icon->shadowed = 1;
aicon->icon->force_paint = 1;
/* We don't do an wAppIconPaint() here because it's in
* wDockAttachIcon(). -Dan
*/
}
wDockAttachIcon(clip, aicon, x, y);
if (clip->collapsed || !clip->mapped)
XUnmapWindow(dpy, aicon->icon->core->window);
}
aicon = aicon->next;
}
}
static void
selectIconsCallback(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *clickedIcon = (WAppIcon*)entry->clientdata;
WDock *dock;
WMArray *selectedIcons;
WMArrayIterator iter;
WAppIcon *btn;
int i;
assert(clickedIcon!=NULL);
dock = clickedIcon->dock;
selectedIcons = getSelected(dock);
if (!WMGetArrayItemCount(selectedIcons)) {
for (i=1; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (btn && !btn->icon->selected) {
wIconSelect(btn->icon);
}
}
} else {
WM_ITERATE_ARRAY(selectedIcons, btn, iter) {
wIconSelect(btn->icon);
}
}
WMFreeArray(selectedIcons);
wMenuPaint(menu);
}
static void
toggleCollapsedCallback(WMenu *menu, WMenuEntry *entry)
{
assert(entry->clientdata!=NULL);
toggleCollapsed(entry->clientdata);
entry->flags.indicator_on = ((WDock*)entry->clientdata)->collapsed;
wMenuPaint(menu);
}
static void
toggleAutoCollapseCallback(WMenu *menu, WMenuEntry *entry)
{
WDock *dock;
assert(entry->clientdata!=NULL);
dock = (WDock*) entry->clientdata;
dock->auto_collapse = !dock->auto_collapse;
entry->flags.indicator_on = ((WDock*)entry->clientdata)->auto_collapse;
wMenuPaint(menu);
}
static void
toggleAutoRaiseLowerCallback(WMenu *menu, WMenuEntry *entry)
{
WDock *dock;
assert(entry->clientdata!=NULL);
dock = (WDock*) entry->clientdata;
dock->auto_raise_lower = !dock->auto_raise_lower;
entry->flags.indicator_on = ((WDock*)entry->clientdata)->auto_raise_lower;
wMenuPaint(menu);
}
static void
launchCallback(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *btn = (WAppIcon*)entry->clientdata;
launchDockedApplication(btn, False);
}
static void
settingsCallback(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *btn = (WAppIcon*)entry->clientdata;
if (btn->editing)
return;
ShowDockAppSettingsPanel(btn);
}
static void
hideCallback(WMenu *menu, WMenuEntry *entry)
{
WApplication *wapp;
WAppIcon *btn = (WAppIcon*)entry->clientdata;
wapp = wApplicationOf(btn->icon->owner->main_window);
if (wapp->flags.hidden) {
wWorkspaceChange(btn->icon->core->screen_ptr,wapp->last_workspace);
wUnhideApplication(wapp, False, False);
} else {
wHideApplication(wapp);
}
}
static void
unhideHereCallback(WMenu *menu, WMenuEntry *entry)
{
WApplication *wapp;
WAppIcon *btn = (WAppIcon*)entry->clientdata;
wapp = wApplicationOf(btn->icon->owner->main_window);
wUnhideApplication(wapp, False, True);
}
WAppIcon*
mainIconCreate(WScreen *scr, int type)
{
WAppIcon *btn;
int x_pos;
if (type == WM_CLIP) {
if (scr->clip_icon)
return scr->clip_icon;
btn = wAppIconCreateForDock(scr, NULL, "Logo", "WMClip", TILE_CLIP);
btn->icon->core->descriptor.handle_expose = clipIconExpose;
btn->icon->core->descriptor.handle_enternotify = clipEnterNotify;
btn->icon->core->descriptor.handle_leavenotify = clipLeaveNotify;
/*x_pos = scr->scr_width - ICON_SIZE*2 - DOCK_EXTRA_SPACE;*/
x_pos = 0;
} else {
btn = wAppIconCreateForDock(scr, NULL, "Logo", "WMDock", TILE_NORMAL);
x_pos = scr->scr_width - ICON_SIZE - DOCK_EXTRA_SPACE;
}
btn->xindex = 0;
btn->yindex = 0;
btn->icon->core->descriptor.handle_mousedown = iconMouseDown;
btn->icon->core->descriptor.parent_type = WCLASS_DOCK_ICON;
btn->icon->core->descriptor.parent = btn;
/*ChangeStackingLevel(btn->icon->core, WMDockLevel);*/
XMapWindow(dpy, btn->icon->core->window);
btn->x_pos = x_pos;
btn->y_pos = 0;
btn->docked = 1;
if (type == WM_CLIP)
scr->clip_icon = btn;
return btn;
}
static void
switchWSCommand(WMenu *menu, WMenuEntry *entry)
{
WAppIcon *btn, *icon = (WAppIcon*) entry->clientdata;
WScreen *scr = icon->icon->core->screen_ptr;
WDock *src, *dest;
WMArray *selectedIcons;
int x, y;
if (entry->order == scr->current_workspace)
return;
src = icon->dock;
dest = scr->workspaces[entry->order]->clip;
selectedIcons = getSelected(src);
if (WMGetArrayItemCount(selectedIcons)) {
WMArrayIterator iter;
WM_ITERATE_ARRAY(selectedIcons, btn, iter) {
if (wDockFindFreeSlot(dest, &x, &y)) {
moveIconBetweenDocks(src, dest, btn, x, y);
XUnmapWindow(dpy, btn->icon->core->window);
}
}
} else if (icon != scr->clip_icon) {
if (wDockFindFreeSlot(dest, &x, &y)) {
moveIconBetweenDocks(src, dest, icon, x, y);
XUnmapWindow(dpy, icon->icon->core->window);
}
}
WMFreeArray(selectedIcons);
}
static void
launchDockedApplication(WAppIcon *btn, Bool withSelection)
{
WScreen *scr = btn->icon->core->screen_ptr;
if (!btn->launching &&
((!withSelection && btn->command!=NULL) ||
(withSelection && btn->paste_command!=NULL))) {
if (!btn->forced_dock) {
btn->relaunching = btn->running;
btn->running = 1;
}
if (btn->wm_instance || btn->wm_class) {
WWindowAttributes attr;
memset(&attr, 0, sizeof(WWindowAttributes));
wDefaultFillAttributes(scr, btn->wm_instance, btn->wm_class,
&attr, NULL, True);
if (!attr.no_appicon && !btn->buggy_app)
btn->launching = 1;
else
btn->running = 0;
}
btn->drop_launch = 0;
btn->paste_launch = withSelection;
scr->last_dock = btn->dock;
btn->pid = execCommand(btn,
withSelection ? btn->paste_command : btn->command,
NULL);
if (btn->pid>0) {
if (btn->buggy_app) {
/* give feedback that the app was launched */
btn->launching = 1;
dockIconPaint(btn);
btn->launching = 0;
WMAddTimerHandler(200, (WMCallback*)dockIconPaint, btn);
} else {
dockIconPaint(btn);
}
} else {
wwarning(_("could not launch application %s\n"), btn->command);
btn->launching = 0;
if (!btn->relaunching)
btn->running = 0;
}
}
}
static void
updateWorkspaceMenu(WMenu *menu, WAppIcon *icon)
{
WScreen *scr = menu->frame->screen_ptr;
char title[MAX_WORKSPACENAME_WIDTH+1];
int i;
if (!menu || !icon)
return;
for (i=0; i<scr->workspace_count; i++) {
if (i < menu->entry_no) {
if (strcmp(menu->entries[i]->text,scr->workspaces[i]->name)!=0) {
wfree(menu->entries[i]->text);
strcpy(title, scr->workspaces[i]->name);
menu->entries[i]->text = wstrdup(title);
menu->flags.realized = 0;
}
menu->entries[i]->clientdata = (void*)icon;
} else {
strcpy(title, scr->workspaces[i]->name);
wMenuAddCallback(menu, title, switchWSCommand, (void*)icon);
menu->flags.realized = 0;
}
if (i == scr->current_workspace) {
wMenuSetEnabled(menu, i, False);
} else {
wMenuSetEnabled(menu, i, True);
}
}
if (!menu->flags.realized)
wMenuRealize(menu);
}
static WMenu*
makeWorkspaceMenu(WScreen *scr)
{
WMenu *menu;
menu = wMenuCreate(scr, NULL, False);
if (!menu)
wwarning(_("could not create workspace submenu for Clip menu"));
wMenuAddCallback(menu, "", switchWSCommand, (void*)scr->clip_icon);
menu->flags.realized = 0;
wMenuRealize(menu);
return menu;
}
static void
updateClipOptionsMenu(WMenu *menu, WDock *dock)
{
WMenuEntry *entry;
int index = 0;
if (!menu || !dock)
return;
/* keep on top */
entry = menu->entries[index];
entry->flags.indicator_on = !dock->lowered;
entry->clientdata = dock;
/* collapsed */
entry = menu->entries[++index];
entry->flags.indicator_on = dock->collapsed;
entry->clientdata = dock;
/* auto-collapse */
entry = menu->entries[++index];
entry->flags.indicator_on = dock->auto_collapse;
entry->clientdata = dock;
/* auto-raise/lower */
entry = menu->entries[++index];
entry->flags.indicator_on = dock->auto_raise_lower;
entry->clientdata = dock;
/* attract icons */
entry = menu->entries[++index];
entry->flags.indicator_on = dock->attract_icons;
entry->clientdata = dock;
menu->flags.realized = 0;
wMenuRealize(menu);
}
static WMenu*
makeClipOptionsMenu(WScreen *scr)
{
WMenu *menu;
WMenuEntry *entry;
menu = wMenuCreate(scr, NULL, False);
if (!menu) {
wwarning(_("could not create options submenu for Clip menu"));
return NULL;
}
entry = wMenuAddCallback(menu, _("Keep on Top"),
toggleLoweredCallback, NULL);
entry->flags.indicator = 1;
entry->flags.indicator_on = 1;
entry->flags.indicator_type = MI_CHECK;
entry = wMenuAddCallback(menu, _("Collapsed"),
toggleCollapsedCallback, NULL);
entry->flags.indicator = 1;
entry->flags.indicator_on = 1;
entry->flags.indicator_type = MI_CHECK;
entry = wMenuAddCallback(menu, _("Autocollapse"),
toggleAutoCollapseCallback, NULL);
entry->flags.indicator = 1;
entry->flags.indicator_on = 1;
entry->flags.indicator_type = MI_CHECK;
entry = wMenuAddCallback(menu, _("Autoraise"),
toggleAutoRaiseLowerCallback, NULL);
entry->flags.indicator = 1;
entry->flags.indicator_on = 1;
entry->flags.indicator_type = MI_CHECK;
entry = wMenuAddCallback(menu, _("Autoattract Icons"),
toggleAutoAttractCallback, NULL);
entry->flags.indicator = 1;
entry->flags.indicator_on = 1;
entry->flags.indicator_type = MI_CHECK;
menu->flags.realized = 0;
wMenuRealize(menu);
return menu;
}
static WMenu*
dockMenuCreate(WScreen *scr, int type)
{
WMenu *menu;
WMenuEntry *entry;
if (type == WM_CLIP && scr->clip_menu)
return scr->clip_menu;
menu = wMenuCreate(scr, NULL, False);
if (type != WM_CLIP) {
entry = wMenuAddCallback(menu, _("Keep on Top"),
toggleLoweredCallback, NULL);
entry->flags.indicator = 1;
entry->flags.indicator_on = 1;
entry->flags.indicator_type = MI_CHECK;
} else {
entry = wMenuAddCallback(menu, _("Clip Options"), NULL, NULL);
scr->clip_options = makeClipOptionsMenu(scr);
if (scr->clip_options)
wMenuEntrySetCascade(menu, entry, scr->clip_options);
entry = wMenuAddCallback(menu, _("Rename Workspace"), renameCallback,
NULL);
wfree(entry->text);
entry->text = _("Rename Workspace");
entry = wMenuAddCallback(menu, _("Selected"), selectCallback, NULL);
entry->flags.indicator = 1;
entry->flags.indicator_on = 1;
entry->flags.indicator_type = MI_CHECK;
entry = wMenuAddCallback(menu, _("Select All Icons"),
selectIconsCallback, NULL);
wfree(entry->text);
entry->text = _("Select All Icons");
entry = wMenuAddCallback(menu, _("Keep Icon"), keepIconsCallback, NULL);
wfree(entry->text);
entry->text = _("Keep Icon");
entry = wMenuAddCallback(menu, _("Move Icon To"), NULL, NULL);
wfree(entry->text);
entry->text = _("Move Icon To");
scr->clip_submenu = makeWorkspaceMenu(scr);
if (scr->clip_submenu)
wMenuEntrySetCascade(menu, entry, scr->clip_submenu);
entry = wMenuAddCallback(menu, _("Remove Icon"), removeIconsCallback,
NULL);
wfree(entry->text);
entry->text = _("Remove Icon");
wMenuAddCallback(menu, _("Attract Icons"), colectIconsCallback, NULL);
}
wMenuAddCallback(menu, _("Launch"), launchCallback, NULL);
wMenuAddCallback(menu, _("Unhide Here"), unhideHereCallback, NULL);
entry = wMenuAddCallback(menu, _("Hide"), hideCallback, NULL);
wfree(entry->text);
entry->text = _("Hide");
wMenuAddCallback(menu, _("Settings..."), settingsCallback, NULL);
wMenuAddCallback(menu, _("Kill"), killCallback, NULL);
if (type == WM_CLIP)
scr->clip_menu = menu;
return menu;
}
WDock*
wDockCreate(WScreen *scr, int type)
{
WDock *dock;
WAppIcon *btn;
int icon_count;
make_keys();
dock = wmalloc(sizeof(WDock));
memset(dock, 0, sizeof(WDock));
if (type == WM_CLIP)
icon_count = CLIP_MAX_ICONS;
else
icon_count = scr->scr_height/wPreferences.icon_size;
dock->icon_array = wmalloc(sizeof(WAppIcon*)*icon_count);
memset(dock->icon_array, 0, sizeof(WAppIcon*)*icon_count);
dock->max_icons = icon_count;
btn = mainIconCreate(scr, type);
btn->dock = dock;
dock->x_pos = btn->x_pos;
dock->y_pos = btn->y_pos;
dock->screen_ptr = scr;
dock->type = type;
dock->icon_count = 1;
dock->on_right_side = 1;
dock->collapsed = 0;
dock->auto_collapse = 0;
dock->auto_collapse_magic = NULL;
dock->auto_raise_lower = 0;
dock->auto_lower_magic = NULL;
dock->auto_raise_magic = NULL;
dock->attract_icons = 0;
dock->lowered = 1;
dock->icon_array[0] = btn;
wRaiseFrame(btn->icon->core);
XMoveWindow(dpy, btn->icon->core->window, btn->x_pos, btn->y_pos);
/* create dock menu */
dock->menu = dockMenuCreate(scr, type);
return dock;
}
void
wDockDestroy(WDock *dock)
{
int i;
WAppIcon *aicon;
for (i=(dock->type == WM_CLIP) ? 1 : 0; i<dock->max_icons; i++) {
aicon = dock->icon_array[i];
if (aicon) {
int keepit = aicon->running && wApplicationOf(aicon->main_window);
wDockDetach(dock, aicon);
if (keepit) {
PlaceIcon(dock->screen_ptr, &aicon->x_pos, &aicon->y_pos);
XMoveWindow(dpy, aicon->icon->core->window,
aicon->x_pos, aicon->y_pos);
if (!dock->mapped || dock->collapsed)
XMapWindow(dpy, aicon->icon->core->window);
}
}
}
if (wPreferences.auto_arrange_icons)
wArrangeIcons(dock->screen_ptr, True);
wfree(dock->icon_array);
if (dock->menu && dock->type!=WM_CLIP)
wMenuDestroy(dock->menu, True);
if (dock->screen_ptr->last_dock == dock)
dock->screen_ptr->last_dock = NULL;
wfree(dock);
}
void
wClipIconPaint(WAppIcon *aicon)
{
WScreen *scr = aicon->icon->core->screen_ptr;
WWorkspace *workspace = scr->workspaces[scr->current_workspace];
GC gc;
Window win = aicon->icon->core->window;
int length, nlength;
char *ws_name, ws_number[10];
int ty, tx;
wIconPaint(aicon->icon);
length = strlen(workspace->name);
ws_name = wmalloc(length + 1);
snprintf(ws_name, length+1, "%s", workspace->name);
snprintf(ws_number, sizeof(ws_number), "%i", scr->current_workspace + 1);
nlength = strlen(ws_number);
gc = scr->clip_title_gc;
if (!workspace->clip->collapsed)
XSetForeground(dpy, gc, scr->clip_title_pixel[CLIP_NORMAL]);
else
XSetForeground(dpy, gc, scr->clip_title_pixel[CLIP_COLLAPSED]);
ty = ICON_SIZE - WMFontHeight(scr->clip_title_font) - 3;
tx = CLIP_BUTTON_SIZE*ICON_SIZE/64;
WMDrawString(scr->wmscreen, win, gc, scr->clip_title_font, tx,
ty, ws_name, length);
tx = (ICON_SIZE/2 - WMWidthOfString(scr->clip_title_font, ws_number,
nlength))/2;
WMDrawString(scr->wmscreen, win, gc, scr->clip_title_font, tx,
2, ws_number, nlength);
wfree(ws_name);
if (aicon->launching) {
XFillRectangle(dpy, aicon->icon->core->window, scr->stipple_gc,
0, 0, wPreferences.icon_size, wPreferences.icon_size);
}
paintClipButtons(aicon, aicon->dock->lclip_button_pushed,
aicon->dock->rclip_button_pushed);
}
static void
clipIconExpose(WObjDescriptor *desc, XEvent *event)
{
wClipIconPaint(desc->parent);
}
static void
dockIconPaint(WAppIcon *btn)
{
if (btn == btn->icon->core->screen_ptr->clip_icon)
wClipIconPaint(btn);
else
wAppIconPaint(btn);
}
static WMPropList*
make_icon_state(WAppIcon *btn)
{
WMPropList *node = NULL;
WMPropList *command, *autolaunch, *lock, *name, *forced, *host;
WMPropList *position, *buggy, *omnipresent;
char *tmp;
char buffer[64];
if (btn) {
if (!btn->command)
command = WMCreatePLString("-");
else
command = WMCreatePLString(btn->command);
autolaunch = btn->auto_launch ? dYes : dNo;
lock = btn->lock ? dYes : dNo;
tmp = EscapeWM_CLASS(btn->wm_instance, btn->wm_class);
name = WMCreatePLString(tmp);
wfree(tmp);
forced = btn->forced_dock ? dYes : dNo;
buggy = btn->buggy_app ? dYes : dNo;
if (btn == btn->icon->core->screen_ptr->clip_icon)
snprintf(buffer, sizeof(buffer), "%i,%i", btn->x_pos, btn->y_pos);
else
snprintf(buffer, sizeof(buffer), "%hi,%hi", btn->xindex, btn->yindex);
position = WMCreatePLString(buffer);
node = WMCreatePLDictionary(dCommand, command,
dName, name,
dAutoLaunch, autolaunch,
dLock, lock,
dForced, forced,
dBuggyApplication, buggy,
dPosition, position,
NULL);
WMReleasePropList(command);
WMReleasePropList(name);
WMReleasePropList(position);
omnipresent = btn->omnipresent ? dYes : dNo;
if (btn->dock != btn->icon->core->screen_ptr->dock &&
(btn->xindex != 0 || btn->yindex != 0))
WMPutInPLDictionary(node, dOmnipresent, omnipresent);
#ifdef OFFIX_DND
if (btn->dnd_command) {
command = WMCreatePLString(btn->dnd_command);
WMPutInPLDictionary(node, dDropCommand, command);
WMReleasePropList(command);
}
#endif /* OFFIX_DND */
if (btn->paste_command) {
command = WMCreatePLString(btn->paste_command);
WMPutInPLDictionary(node, dPasteCommand, command);
WMReleasePropList(command);
}
if (btn->client_machine && btn->remote_start) {
host = WMCreatePLString(btn->client_machine);
WMPutInPLDictionary(node, dHost, host);
WMReleasePropList(host);
}
}
return node;
}
static WMPropList*
dockSaveState(WDock *dock)
{
int i;
WMPropList *icon_info;
WMPropList *list=NULL, *dock_state=NULL;
WMPropList *value, *key;
char buffer[256];
list = WMCreatePLArray(NULL);
for (i=(dock->type==WM_DOCK ? 0 : 1); i<dock->max_icons; i++) {
WAppIcon *btn = dock->icon_array[i];
if (!btn || btn->attracted)
continue;
if ((icon_info = make_icon_state(dock->icon_array[i]))) {
WMAddToPLArray(list, icon_info);
WMReleasePropList(icon_info);
}
}
dock_state = WMCreatePLDictionary(dApplications, list,
NULL);
if (dock->type == WM_DOCK) {
snprintf(buffer, sizeof(buffer), "Applications%i", dock->screen_ptr->scr_height);
key = WMCreatePLString(buffer);
WMPutInPLDictionary(dock_state, key, list);
WMReleasePropList(key);
snprintf(buffer, sizeof(buffer), "%i,%i", (dock->on_right_side ? -ICON_SIZE : 0),
dock->y_pos);
value = WMCreatePLString(buffer);
WMPutInPLDictionary(dock_state, dPosition, value);
WMReleasePropList(value);
}
WMReleasePropList(list);
value = (dock->lowered ? dYes : dNo);
WMPutInPLDictionary(dock_state, dLowered, value);
if (dock->type == WM_CLIP) {
value = (dock->collapsed ? dYes : dNo);
WMPutInPLDictionary(dock_state, dCollapsed, value);
value = (dock->auto_collapse ? dYes : dNo);
WMPutInPLDictionary(dock_state, dAutoCollapse, value);
value = (dock->auto_raise_lower ? dYes : dNo);
WMPutInPLDictionary(dock_state, dAutoRaiseLower, value);
value = (dock->attract_icons ? dYes : dNo);
WMPutInPLDictionary(dock_state, dAutoAttractIcons, value);
}
return dock_state;
}
void
wDockSaveState(WScreen *scr, WMPropList *old_state)
{
WMPropList *dock_state;
WMPropList *keys;
dock_state = dockSaveState(scr->dock);
/*
* Copy saved states of docks with different sizes.
*/
if (old_state) {
int i;
WMPropList *tmp;
keys = WMGetPLDictionaryKeys(old_state);
for (i = 0; i < WMGetPropListItemCount(keys); i++) {
tmp = WMGetFromPLArray(keys, i);
if (strncasecmp(WMGetFromPLString(tmp), "applications", 12) == 0
&& !WMGetFromPLDictionary(dock_state, tmp)) {
WMPutInPLDictionary(dock_state,
tmp,
WMGetFromPLDictionary(old_state, tmp));
}
}
WMReleasePropList(keys);
}
WMPutInPLDictionary(scr->session_state, dDock, dock_state);
WMReleasePropList(dock_state);
}
void
wClipSaveState(WScreen *scr)
{
WMPropList *clip_state;
clip_state = make_icon_state(scr->clip_icon);
WMPutInPLDictionary(scr->session_state, dClip, clip_state);
WMReleasePropList(clip_state);
}
WMPropList*
wClipSaveWorkspaceState(WScreen *scr, int workspace)
{
return dockSaveState(scr->workspaces[workspace]->clip);
}
static Bool
getBooleanDockValue(WMPropList *value, WMPropList *key)
{
if (value) {
if (WMIsPLString(value)) {
if (strcasecmp(WMGetFromPLString(value), "YES")==0)
return True;
} else {
wwarning(_("bad value in docked icon state info %s"),
WMGetFromPLString(key));
}
}
return False;
}
static WAppIcon*
restore_icon_state(WScreen *scr, WMPropList *info, int type, int index)
{
WAppIcon *aicon;
WMPropList *cmd, *value;
cmd = WMGetFromPLDictionary(info, dCommand);
if (!cmd || !WMIsPLString(cmd)) {
return NULL;
}
/* parse window name */
value = WMGetFromPLDictionary(info, dName);
if (!value)
return NULL;
{
char *wclass, *winstance;
char *command;
ParseWindowName(value, &winstance, &wclass, "dock");
if (!winstance && !wclass) {
return NULL;
}
/* get commands */
if (cmd)
command = wstrdup(WMGetFromPLString(cmd));
else
command = NULL;
if (!command || strcmp(command, "-")==0) {
if (command)
wfree(command);
if (wclass)
wfree(wclass);
if (winstance)
wfree(winstance);
return NULL;
}
aicon = wAppIconCreateForDock(scr, command, winstance, wclass,
TILE_NORMAL);
if (wclass)
wfree(wclass);
if (winstance)
wfree(winstance);
if (command)
wfree(command);
}
aicon->icon->core->descriptor.handle_mousedown = iconMouseDown;
if (type == WM_CLIP) {
aicon->icon->core->descriptor.handle_enternotify = clipEnterNotify;
aicon->icon->core->descriptor.handle_leavenotify = clipLeaveNotify;
}
aicon->icon->core->descriptor.parent_type = WCLASS_DOCK_ICON;
aicon->icon->core->descriptor.parent = aicon;
#ifdef OFFIX_DND
cmd = WMGetFromPLDictionary(info, dDropCommand);
if (cmd)
aicon->dnd_command = wstrdup(WMGetFromPLString(cmd));
#endif
cmd = WMGetFromPLDictionary(info, dPasteCommand);
if (cmd)
aicon->paste_command = wstrdup(WMGetFromPLString(cmd));
/* check auto launch */
value = WMGetFromPLDictionary(info, dAutoLaunch);
aicon->auto_launch = getBooleanDockValue(value, dAutoLaunch);
/* check lock */
value = WMGetFromPLDictionary(info, dLock);
aicon->lock = getBooleanDockValue(value, dLock);
/* check if it wasn't normally docked */
value = WMGetFromPLDictionary(info, dForced);
aicon->forced_dock = getBooleanDockValue(value, dForced);
/* check if we can rely on the stuff in the app */
value = WMGetFromPLDictionary(info, dBuggyApplication);
aicon->buggy_app = getBooleanDockValue(value, dBuggyApplication);
/* get position in the dock */
value = WMGetFromPLDictionary(info, dPosition);
if (value && WMIsPLString(value)) {
if (sscanf(WMGetFromPLString(value), "%hi,%hi", &aicon->xindex,
&aicon->yindex)!=2)
wwarning(_("bad value in docked icon state info %s"),
WMGetFromPLString(dPosition));
/* check position sanity */
/* incomplete section! */
if (type == WM_DOCK) {
aicon->xindex = 0;
if (aicon->yindex < 0)
wwarning(_("bad value in docked icon position %i,%i"),
aicon->xindex, aicon->yindex);
}
} else {
aicon->yindex = index;
aicon->xindex = 0;
}
/* check if icon is omnipresent */
value = WMGetFromPLDictionary(info, dOmnipresent);
aicon->omnipresent = getBooleanDockValue(value, dOmnipresent);
aicon->running = 0;
aicon->docked = 1;
return aicon;
}
#define COMPLAIN(key) wwarning(_("bad value in dock state info:%s"), key)
WAppIcon*
wClipRestoreState(WScreen *scr, WMPropList *clip_state)
{
WAppIcon *icon;
WMPropList *value;
icon = mainIconCreate(scr, WM_CLIP);
if (!clip_state)
return icon;
else
WMRetainPropList(clip_state);
/* restore position */
value = WMGetFromPLDictionary(clip_state, dPosition);
if (value) {
if (!WMIsPLString(value))
COMPLAIN("Position");
else {
if (sscanf(WMGetFromPLString(value), "%i,%i", &icon->x_pos,
&icon->y_pos)!=2)
COMPLAIN("Position");
/* check position sanity */
if (icon->y_pos < 0)
icon->y_pos = 0;
else if (icon->y_pos > scr->scr_height-ICON_SIZE)
icon->y_pos = scr->scr_height-ICON_SIZE;
if (icon->x_pos < 0)
icon->x_pos = 0;
else if (icon->x_pos > scr->scr_width-ICON_SIZE)
icon->x_pos = scr->scr_width-ICON_SIZE;
}
}
#ifdef OFFIX_DND
value = WMGetFromPLDictionary(clip_state, dDropCommand);
if (value && WMIsPLString(value))
icon->dnd_command = wstrdup(WMGetFromPLString(value));
#endif
value = WMGetFromPLDictionary(clip_state, dPasteCommand);
if (value && WMIsPLString(value))
icon->paste_command = wstrdup(WMGetFromPLString(value));
WMReleasePropList(clip_state);
return icon;
}
WDock*
wDockRestoreState(WScreen *scr, WMPropList *dock_state, int type)
{
WDock *dock;
WMPropList *apps;
WMPropList *value;
WAppIcon *aicon, *old_top;
int count, i;
dock = wDockCreate(scr, type);
if (!dock_state)
return dock;
if (dock_state)
WMRetainPropList(dock_state);
/* restore position */
value = WMGetFromPLDictionary(dock_state, dPosition);
if (value) {
if (!WMIsPLString(value))
COMPLAIN("Position");
else {
if (sscanf(WMGetFromPLString(value), "%i,%i", &dock->x_pos,
&dock->y_pos)!=2)
COMPLAIN("Position");
/* check position sanity */
if (dock->y_pos < 0)
dock->y_pos = 0;
else if (dock->y_pos > scr->scr_height-ICON_SIZE)
dock->y_pos = scr->scr_height - ICON_SIZE;
/* This is no more needed. ??? */
if (type == WM_CLIP) {
if (dock->x_pos < 0)
dock->x_pos = 0;
else if (dock->x_pos > scr->scr_width-ICON_SIZE)
dock->x_pos = scr->scr_width-ICON_SIZE;
} else {
if (dock->x_pos >= 0) {
dock->x_pos = DOCK_EXTRA_SPACE;
dock->on_right_side = 0;
} else {
dock->x_pos = scr->scr_width - DOCK_EXTRA_SPACE - ICON_SIZE;
dock->on_right_side = 1;
}
}
}
}
/* restore lowered/raised state */
dock->lowered = 0;
value = WMGetFromPLDictionary(dock_state, dLowered);
if (value) {
if (!WMIsPLString(value))
COMPLAIN("Lowered");
else {
if (strcasecmp(WMGetFromPLString(value), "YES")==0)
dock->lowered = 1;
}
}
/* restore collapsed state */
dock->collapsed = 0;
value = WMGetFromPLDictionary(dock_state, dCollapsed);
if (value) {
if (!WMIsPLString(value))
COMPLAIN("Collapsed");
else {
if (strcasecmp(WMGetFromPLString(value), "YES")==0)
dock->collapsed = 1;
}
}
/* restore auto-collapsed state */
value = WMGetFromPLDictionary(dock_state, dAutoCollapse);
if (value) {
if (!WMIsPLString(value))
COMPLAIN("AutoCollapse");
else {
if (strcasecmp(WMGetFromPLString(value), "YES")==0) {
dock->auto_collapse = 1;
dock->collapsed = 1;
}
}
}
/* restore auto-raise/lower state */
value = WMGetFromPLDictionary(dock_state, dAutoRaiseLower);
if (value) {
if (!WMIsPLString(value))
COMPLAIN("AutoRaiseLower");
else {
if (strcasecmp(WMGetFromPLString(value), "YES")==0) {
dock->auto_raise_lower = 1;
}
}
}
/* restore attract icons state */
dock->attract_icons = 0;
value = WMGetFromPLDictionary(dock_state, dAutoAttractIcons);
if (value) {
if (!WMIsPLString(value))
COMPLAIN("AutoAttractIcons");
else {
if (strcasecmp(WMGetFromPLString(value), "YES")==0)
dock->attract_icons = 1;
}
}
/* application list */
{
WMPropList *tmp;
char buffer[64];
/*
* When saving, it saves the dock state in
* Applications and Applicationsnnn
*
* When loading, it will first try Applicationsnnn.
* If it does not exist, use Applications as default.
*/
snprintf(buffer, sizeof(buffer), "Applications%i", scr->scr_height);
tmp = WMCreatePLString(buffer);
apps = WMGetFromPLDictionary(dock_state, tmp);
WMReleasePropList(tmp);
if (!apps) {
apps = WMGetFromPLDictionary(dock_state, dApplications);
}
}
if (!apps) {
goto finish;
}
count = WMGetPropListItemCount(apps);
if (count==0)
goto finish;
old_top = dock->icon_array[0];
/* dock->icon_count is set to 1 when dock is created.
* Since Clip is already restored, we want to keep it so for clip,
* but for dock we may change the default top tile, so we set it to 0.
*/
if (type == WM_DOCK)
dock->icon_count = 0;
for (i=0; i<count; i++) {
if (dock->icon_count >= dock->max_icons) {
wwarning(_("there are too many icons stored in dock. Ignoring what doesn't fit"));
break;
}
value = WMGetFromPLArray(apps, i);
aicon = restore_icon_state(scr, value, type, dock->icon_count);
dock->icon_array[dock->icon_count] = aicon;
if (aicon) {
aicon->dock = dock;
aicon->x_pos = dock->x_pos + (aicon->xindex*ICON_SIZE);
aicon->y_pos = dock->y_pos + (aicon->yindex*ICON_SIZE);
if (dock->lowered)
ChangeStackingLevel(aicon->icon->core, WMNormalLevel);
else
ChangeStackingLevel(aicon->icon->core, WMDockLevel);
wCoreConfigure(aicon->icon->core, aicon->x_pos, aicon->y_pos,
0, 0);
if (!dock->collapsed)
XMapWindow(dpy, aicon->icon->core->window);
wRaiseFrame(aicon->icon->core);
dock->icon_count++;
} else if (dock->icon_count==0 && type==WM_DOCK)
dock->icon_count++;
}
/* if the first icon is not defined, use the default */
if (dock->icon_array[0]==NULL) {
/* update default icon */
old_top->x_pos = dock->x_pos;
old_top->y_pos = dock->y_pos;
if (dock->lowered)
ChangeStackingLevel(old_top->icon->core, WMNormalLevel);
else
ChangeStackingLevel(old_top->icon->core, WMDockLevel);
dock->icon_array[0] = old_top;
XMoveWindow(dpy, old_top->icon->core->window, dock->x_pos, dock->y_pos);
/* we don't need to increment dock->icon_count here because it was
* incremented in the loop above.
*/
} else if (old_top!=dock->icon_array[0]) {
if (old_top == scr->clip_icon)
scr->clip_icon = dock->icon_array[0];
wAppIconDestroy(old_top);
}
finish:
if (dock_state)
WMReleasePropList(dock_state);
return dock;
}
void
wDockLaunchWithState(WDock *dock, WAppIcon *btn, WSavedState *state)
{
if (btn && btn->command && !btn->running && !btn->launching) {
btn->drop_launch = 0;
btn->paste_launch = 0;
btn->pid = execCommand(btn, btn->command, state);
if (btn->pid>0) {
if (!btn->forced_dock && !btn->buggy_app) {
btn->launching = 1;
dockIconPaint(btn);
}
}
} else {
wfree(state);
}
}
void
wDockDoAutoLaunch(WDock *dock, int workspace)
{
WAppIcon *btn;
WSavedState *state;
int i;
for (i = 0; i < dock->max_icons; i++) {
btn = dock->icon_array[i];
if (!btn || !btn->auto_launch)
continue;
state = wmalloc(sizeof(WSavedState));
memset(state, 0, sizeof(WSavedState));
state->workspace = workspace;
/* TODO: this is klugy and is very difficult to understand
* what's going on. Try to clean up */
wDockLaunchWithState(dock, btn, state);
}
}
#ifdef OFFIX_DND
static WDock*
findDock(WScreen *scr, XEvent *event, int *icon_pos)
{
WDock *dock;
int i;
*icon_pos = -1;
if ((dock = scr->dock)!=NULL) {
for (i=0; i<dock->max_icons; i++) {
if (dock->icon_array[i]
&& dock->icon_array[i]->icon->core->window==event->xclient.window) {
*icon_pos = i;
break;
}
}
}
if (*icon_pos<0 && (dock = scr->workspaces[scr->current_workspace]->clip)!=NULL) {
for (i=0; i<dock->max_icons; i++) {
if (dock->icon_array[i]
&& dock->icon_array[i]->icon->core->window==event->xclient.window) {
*icon_pos = i;
break;
}
}
}
if(*icon_pos>=0)
return dock;
return NULL;
}
int
wDockReceiveDNDDrop(WScreen *scr, XEvent *event)
{
WDock *dock;
WAppIcon *btn;
int icon_pos;
dock = findDock(scr, event, &icon_pos);
if (!dock)
return False;
/*
* Return True if the drop was on an application icon window.
* In this case, let the ClientMessage handler redirect the
* message to the app.
*/
if (dock->icon_array[icon_pos]->icon->icon_win!=None)
return True;
if (dock->icon_array[icon_pos]->dnd_command!=NULL) {
scr->flags.dnd_data_convertion_status = 0;
btn = dock->icon_array[icon_pos];
if (!btn->forced_dock) {
btn->relaunching = btn->running;
btn->running = 1;
}
if (btn->wm_instance || btn->wm_class) {
WWindowAttributes attr;
memset(&attr, 0, sizeof(WWindowAttributes));
wDefaultFillAttributes(btn->icon->core->screen_ptr,
btn->wm_instance,
btn->wm_class, &attr, NULL, True);
if (!attr.no_appicon)
btn->launching = 1;
else
btn->running = 0;
}
btn->paste_launch = 0;
btn->drop_launch = 1;
scr->last_dock = dock;
btn->pid = execCommand(btn, btn->dnd_command, NULL);
if (btn->pid>0) {
dockIconPaint(btn);
} else {
btn->launching = 0;
if (!btn->relaunching) {
btn->running = 0;
}
}
}
return False;
}
#endif /* OFFIX_DND */
Bool
wDockAttachIcon(WDock *dock, WAppIcon *icon, int x, int y)
{
WWindow *wwin;
char **argv;
int argc;
int index;
wwin = icon->icon->owner;
if (icon->command==NULL) {
icon->editing = 0;
if (XGetCommand(dpy, wwin->client_win, &argv, &argc) && argc>0) {
icon->command = wtokenjoin(argv, argc);
XFreeStringList(argv);
} else {
char *command=NULL;
/* icon->forced_dock = 1;*/
if (dock->type!=WM_CLIP || !icon->attracted) {
icon->editing = 1;
if (wInputDialog(dock->screen_ptr, _("Dock Icon"),
_("Type the command used to launch the application"),
&command)) {
if (command && (command[0]==0 ||
(command[0]=='-' && command[1]==0))) {
wfree(command);
command = NULL;
}
icon->command = command;
icon->editing = 0;
} else {
icon->editing = 0;
if (command)
wfree(command);
/* If the target is the dock, reject the icon. If
* the target is the clip, make it an attracted icon
*/
if (dock->type==WM_CLIP) {
icon->attracted = 1;
if (!icon->icon->shadowed) {
icon->icon->shadowed = 1;
icon->icon->force_paint = 1;
}
} else {
return False;
}
}
}
}
} else {
icon->editing = 0;
}
for (index=1; index<dock->max_icons; index++)
if (dock->icon_array[index] == NULL)
break;
/* if (index == dock->max_icons)
return; */
assert(index < dock->max_icons);
dock->icon_array[index] = icon;
icon->yindex = y;
icon->xindex = x;
icon->omnipresent = 0;
icon->x_pos = dock->x_pos + x*ICON_SIZE;
icon->y_pos = dock->y_pos + y*ICON_SIZE;
dock->icon_count++;
icon->running = 1;
icon->launching = 0;
icon->docked = 1;
icon->dock = dock;
icon->icon->core->descriptor.handle_mousedown = iconMouseDown;
if (dock->type == WM_CLIP) {
icon->icon->core->descriptor.handle_enternotify = clipEnterNotify;
icon->icon->core->descriptor.handle_leavenotify = clipLeaveNotify;
}
icon->icon->core->descriptor.parent_type = WCLASS_DOCK_ICON;
icon->icon->core->descriptor.parent = icon;
MoveInStackListUnder(dock->icon_array[index-1]->icon->core,
icon->icon->core);
wAppIconMove(icon, icon->x_pos, icon->y_pos);
wAppIconPaint(icon);
if (wPreferences.auto_arrange_icons)
wArrangeIcons(dock->screen_ptr, True);
#ifdef OFFIX_DND
if (icon->command && !icon->dnd_command) {
int len = strlen(icon->command)+8;
icon->dnd_command = wmalloc(len);
snprintf(icon->dnd_command, len, "%s %%d", icon->command);
}
#endif
if (icon->command && !icon->paste_command) {
int len = strlen(icon->command)+8;
icon->paste_command = wmalloc(len);
snprintf(icon->paste_command, len, "%s %%s", icon->command);
}
return True;
}
void
reattachIcon(WDock *dock, WAppIcon *icon, int x, int y)
{
int index;
for(index=1; index<dock->max_icons; index++) {
if(dock->icon_array[index] == icon)
break;
}
assert(index < dock->max_icons);
icon->yindex = y;
icon->xindex = x;
icon->x_pos = dock->x_pos + x*ICON_SIZE;
icon->y_pos = dock->y_pos + y*ICON_SIZE;
}
Bool
moveIconBetweenDocks(WDock *src, WDock *dest, WAppIcon *icon, int x, int y)
{
WWindow *wwin;
char **argv;
int argc;
int index;
if (src == dest)
return True; /* No move needed, we're already there */
if (dest == NULL)
return False;
wwin = icon->icon->owner;
/*
* For the moment we can't do this if we move icons in Clip from one
* workspace to other, because if we move two or more icons without
* command, the dialog box will not be able to tell us to which of the
* moved icons it applies. -Dan
*/
if ((dest->type==WM_DOCK /*|| dest->keep_attracted*/) && icon->command==NULL) {
if (XGetCommand(dpy, wwin->client_win, &argv, &argc) && argc>0) {
icon->command = wtokenjoin(argv, argc);
XFreeStringList(argv);
} else {
char *command=NULL;
icon->editing = 1;
/* icon->forced_dock = 1;*/
if (wInputDialog(src->screen_ptr, _("Dock Icon"),
_("Type the command used to launch the application"),
&command)) {
if (command && (command[0]==0 ||
(command[0]=='-' && command[1]==0))) {
wfree(command);
command = NULL;
}
icon->command = command;
} else {
icon->editing = 0;
if (command)
wfree(command);
return False;
}
icon->editing = 0;
}
}
if (dest->type == WM_DOCK)
wClipMakeIconOmnipresent(icon, False);
for(index=1; index<src->max_icons; index++) {
if(src->icon_array[index] == icon)
break;
}
assert(index < src->max_icons);
src->icon_array[index] = NULL;
src->icon_count--;
for(index=1; index<dest->max_icons; index++) {
if(dest->icon_array[index] == NULL)
break;
}
/* if (index == dest->max_icons)
return; */
assert(index < dest->max_icons);
dest->icon_array[index] = icon;
icon->dock = dest;
/* deselect the icon */
if (icon->icon->selected)
wIconSelect(icon->icon);
if (dest->type == WM_DOCK) {
icon->icon->core->descriptor.handle_enternotify = NULL;
icon->icon->core->descriptor.handle_leavenotify = NULL;
} else {
icon->icon->core->descriptor.handle_enternotify = clipEnterNotify;
icon->icon->core->descriptor.handle_leavenotify = clipLeaveNotify;
}
/* set it to be kept when moving to dock.
* Unless the icon does not have a command set
*/
if (icon->command && dest->type==WM_DOCK) {
icon->attracted = 0;
if (icon->icon->shadowed) {
icon->icon->shadowed = 0;
icon->icon->force_paint = 1;
}
}
if (src->auto_collapse || src->auto_raise_lower)
clipLeave(src);
icon->yindex = y;
icon->xindex = x;
icon->x_pos = dest->x_pos + x*ICON_SIZE;
icon->y_pos = dest->y_pos + y*ICON_SIZE;
dest->icon_count++;
MoveInStackListUnder(dest->icon_array[index-1]->icon->core,
icon->icon->core);
wAppIconPaint(icon);
return True;
}
void
wDockDetach(WDock *dock, WAppIcon *icon)
{
int index;
/* make the settings panel be closed */
if (icon->panel) {
DestroyDockAppSettingsPanel(icon->panel);
}
/* This must be called before icon->dock is set to NULL.
* Don't move it. -Dan
*/
wClipMakeIconOmnipresent(icon, False);
icon->docked = 0;
icon->dock = NULL;
icon->attracted = 0;
icon->auto_launch = 0;
if (icon->icon->shadowed) {
icon->icon->shadowed = 0;
icon->icon->force_paint = 1;
}
/* deselect the icon */
if (icon->icon->selected)
wIconSelect(icon->icon);
if (icon->command) {
wfree(icon->command);
icon->command = NULL;
}
#ifdef OFFIX_DND
if (icon->dnd_command) {
wfree(icon->dnd_command);
icon->dnd_command = NULL;
}
#endif
if (icon->paste_command) {
wfree(icon->paste_command);
icon->paste_command = NULL;
}
for (index=1; index<dock->max_icons; index++)
if (dock->icon_array[index] == icon)
break;
assert(index < dock->max_icons);
dock->icon_array[index] = NULL;
icon->yindex = -1;
icon->xindex = -1;
dock->icon_count--;
/* if the dock is not attached to an application or
* the the application did not set the approriate hints yet,
* destroy the icon */
if (!icon->running || !wApplicationOf(icon->main_window))
wAppIconDestroy(icon);
else {
icon->icon->core->descriptor.handle_mousedown = appIconMouseDown;
icon->icon->core->descriptor.handle_enternotify = NULL;
icon->icon->core->descriptor.handle_leavenotify = NULL;
icon->icon->core->descriptor.parent_type = WCLASS_APPICON;
icon->icon->core->descriptor.parent = icon;
ChangeStackingLevel(icon->icon->core, NORMAL_ICON_LEVEL);
wAppIconPaint(icon);
if (wPreferences.auto_arrange_icons) {
wArrangeIcons(dock->screen_ptr, True);
}
}
if (dock->auto_collapse || dock->auto_raise_lower)
clipLeave(dock);
}
/*
* returns the closest Dock slot index for the passed
* coordinates.
*
* Returns False if icon can't be docked.
*
* Note: this function should NEVER alter ret_x or ret_y, unless it will
* return True. -Dan
*/
Bool
wDockSnapIcon(WDock *dock, WAppIcon *icon, int req_x, int req_y,
int *ret_x, int *ret_y, int redocking)
{
WScreen *scr = dock->screen_ptr;
int dx, dy;
int ex_x, ex_y;
int i, offset = ICON_SIZE/2;
WAppIcon *aicon = NULL;
WAppIcon *nicon = NULL;
int max_y_icons, max_x_icons;
max_x_icons = scr->scr_width/ICON_SIZE;
max_y_icons = scr->scr_height/ICON_SIZE-1;
if (wPreferences.flags.noupdates)
return False;
dx = dock->x_pos;
dy = dock->y_pos;
/* if the dock is full */
if (!redocking &&
(dock->icon_count >= dock->max_icons)) {
return False;
}
/* exact position */
if (req_y < dy)
ex_y = (req_y - offset - dy)/ICON_SIZE;
else
ex_y = (req_y + offset - dy)/ICON_SIZE;
if (req_x < dx)
ex_x = (req_x - offset - dx)/ICON_SIZE;
else
ex_x = (req_x + offset - dx)/ICON_SIZE;
/* check if the icon is outside the screen boundaries */
if (dx + ex_x*ICON_SIZE < -ICON_SIZE+2 ||
dx + ex_x*ICON_SIZE >= scr->scr_width-1 ||
dy + ex_y*ICON_SIZE < -ICON_SIZE+2 ||
dy + ex_y*ICON_SIZE >= scr->scr_height-1)
return False;
if (dock->type == WM_DOCK) {
if (icon->dock != dock && ex_x != 0)
return False;
aicon = NULL;
for (i=0; i<dock->max_icons; i++) {
nicon = dock->icon_array[i];
if (nicon && nicon->yindex == ex_y) {
aicon = nicon;
break;
}
}
if (redocking) {
int sig, done, closest;
/* Possible cases when redocking:
*
* icon dragged out of range of any slot -> false
* icon dragged to range of free slot
* icon dragged to range of same slot
* icon dragged to range of different icon
*/
if (abs(ex_x) > DOCK_DETTACH_THRESHOLD)
return False;
if (ex_y>=0 && ex_y<=max_y_icons && (aicon==icon || !aicon)) {
*ret_x = 0;
*ret_y = ex_y;
return True;
}
/* start looking at the upper slot or lower? */
if (ex_y*ICON_SIZE < (req_y + offset - dy))
sig = 1;
else
sig = -1;
closest = -1;
done = 0;
/* look for closest free slot */
for (i=0; i<(DOCK_DETTACH_THRESHOLD+1)*2 && !done; i++) {
int j;
done = 1;
closest = sig*(i/2) + ex_y;
/* check if this slot is used */
if (closest >= 0) {
for (j = 0; j<dock->max_icons; j++) {
if (dock->icon_array[j]
&& dock->icon_array[j]->yindex==closest) {
/* slot is used by someone else */
if (dock->icon_array[j]!=icon)
done = 0;
break;
}
}
}
sig = -sig;
}
if (done && closest >= 0 && closest <= max_y_icons &&
((ex_y >= closest && ex_y - closest < DOCK_DETTACH_THRESHOLD+1)
||
(ex_y < closest && closest - ex_y <= DOCK_DETTACH_THRESHOLD+1))) {
*ret_x = 0;
*ret_y = closest;
return True;
}
} else { /* !redocking */
/* if slot is free and the icon is close enough, return it */
if (!aicon && ex_x == 0 && ex_y >= 0 && ex_y <= max_y_icons) {
*ret_x = 0;
*ret_y = ex_y;
return True;
}
}
} else { /* CLIP */
int neighbours = 0;
int start, stop, k;
start = icon->omnipresent ? 0 : scr->current_workspace;
stop = icon->omnipresent ? scr->workspace_count : start+1;
aicon = NULL;
for (k=start; k<stop; k++) {
WDock *tmp = scr->workspaces[k]->clip;
if (!tmp)
continue;
for (i=0; i<tmp->max_icons; i++) {
nicon = tmp->icon_array[i];
if (nicon && nicon->xindex == ex_x && nicon->yindex == ex_y) {
aicon = nicon;
break;
}
}
if (aicon)
break;
}
for (k=start; k<stop; k++) {
WDock *tmp = scr->workspaces[k]->clip;
if (!tmp)
continue;
for (i=0; i<tmp->max_icons; i++) {
nicon = tmp->icon_array[i];
if (nicon && nicon != icon && /* Icon can't be it's own neighbour */
(abs(nicon->xindex - ex_x) <= CLIP_ATTACH_VICINITY &&
abs(nicon->yindex - ex_y) <= CLIP_ATTACH_VICINITY)) {
neighbours = 1;
break;
}
}
if (neighbours)
break;
}
if (neighbours && (aicon==NULL || (redocking && aicon == icon))) {
*ret_x = ex_x;
*ret_y = ex_y;
return True;
}
}
return False;
}
#define ON_SCREEN(x, y, sx, ex, sy, ey) \
((((x)+ICON_SIZE/2) >= (sx)) && (((y)+ICON_SIZE/2) >= (sy)) && \
(((x) + (ICON_SIZE/2)) <= (ex)) && (((y) + (ICON_SIZE/2)) <= ey))
/*
* returns true if it can find a free slot in the dock,
* in which case it changes x_pos and y_pos accordingly.
* Else returns false.
*/
Bool
wDockFindFreeSlot(WDock *dock, int *x_pos, int *y_pos)
{
WScreen *scr = dock->screen_ptr;
WAppIcon *btn;
WAppIconChain *chain;
unsigned char *slot_map;
int mwidth;
int r;
int x, y;
int i, done = False;
int corner;
int sx=0, sy=0, ex=scr->scr_width, ey=scr->scr_height;
int extra_count=0;
if (dock->type == WM_CLIP &&
dock != scr->workspaces[scr->current_workspace]->clip)
extra_count = scr->global_icon_count;
/* if the dock is full */
if (dock->icon_count+extra_count >= dock->max_icons) {
return False;
}
if (!wPreferences.flags.nodock && scr->dock) {
if (scr->dock->on_right_side)
ex -= ICON_SIZE + DOCK_EXTRA_SPACE;
else
sx += ICON_SIZE + DOCK_EXTRA_SPACE;
}
if (ex < dock->x_pos)
ex = dock->x_pos;
if (sx > dock->x_pos+ICON_SIZE)
sx = dock->x_pos+ICON_SIZE;
#define C_NONE 0
#define C_NW 1
#define C_NE 2
#define C_SW 3
#define C_SE 4
/* check if clip is in a corner */
if (dock->type==WM_CLIP) {
if (dock->x_pos < 1 && dock->y_pos < 1)
corner = C_NE;
else if (dock->x_pos < 1 && dock->y_pos >= (ey-ICON_SIZE))
corner = C_SE;
else if (dock->x_pos >= (ex-ICON_SIZE)&& dock->y_pos >= (ey-ICON_SIZE))
corner = C_SW;
else if (dock->x_pos >= (ex-ICON_SIZE) && dock->y_pos < 1)
corner = C_NW;
else
corner = C_NONE;
} else
corner = C_NONE;
/* If the clip is in the corner, use only slots that are in the border
* of the screen */
if (corner!=C_NONE) {
char *hmap, *vmap;
int hcount, vcount;
hcount = WMIN(dock->max_icons, scr->scr_width/ICON_SIZE);
vcount = WMIN(dock->max_icons, scr->scr_height/ICON_SIZE);
hmap = wmalloc(hcount+1);
memset(hmap, 0, hcount+1);
vmap = wmalloc(vcount+1);
memset(vmap, 0, vcount+1);
/* mark used positions */
switch (corner) {
case C_NE:
for (i=0; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (!btn)
continue;
if (btn->xindex==0 && btn->yindex > 0 && btn->yindex < vcount)
vmap[btn->yindex] = 1;
else if (btn->yindex==0 && btn->xindex>0 && btn->xindex<hcount)
hmap[btn->xindex] = 1;
}
for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
btn = chain->aicon;
if (btn->xindex==0 && btn->yindex > 0 && btn->yindex < vcount)
vmap[btn->yindex] = 1;
else if (btn->yindex==0 && btn->xindex>0 && btn->xindex<hcount)
hmap[btn->xindex] = 1;
}
break;
case C_NW:
for (i=0; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (!btn)
continue;
if (btn->xindex==0 && btn->yindex > 0 && btn->yindex < vcount)
vmap[btn->yindex] = 1;
else if (btn->yindex==0 && btn->xindex<0 &&btn->xindex>-hcount)
hmap[-btn->xindex] = 1;
}
for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
btn = chain->aicon;
if (btn->xindex==0 && btn->yindex > 0 && btn->yindex < vcount)
vmap[btn->yindex] = 1;
else if (btn->yindex==0 && btn->xindex<0 &&btn->xindex>-hcount)
hmap[-btn->xindex] = 1;
}
break;
case C_SE:
for (i=0; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (!btn)
continue;
if (btn->xindex==0 && btn->yindex < 0 && btn->yindex > -vcount)
vmap[-btn->yindex] = 1;
else if (btn->yindex==0 && btn->xindex>0 && btn->xindex<hcount)
hmap[btn->xindex] = 1;
}
for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
btn = chain->aicon;
if (btn->xindex==0 && btn->yindex < 0 && btn->yindex > -vcount)
vmap[-btn->yindex] = 1;
else if (btn->yindex==0 && btn->xindex>0 && btn->xindex<hcount)
hmap[btn->xindex] = 1;
}
break;
case C_SW:
default:
for (i=0; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (!btn)
continue;
if (btn->xindex==0 && btn->yindex < 0 && btn->yindex > -vcount)
vmap[-btn->yindex] = 1;
else if (btn->yindex==0 && btn->xindex<0 &&btn->xindex>-hcount)
hmap[-btn->xindex] = 1;
}
for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
btn = chain->aicon;
if (btn->xindex==0 && btn->yindex < 0 && btn->yindex > -vcount)
vmap[-btn->yindex] = 1;
else if (btn->yindex==0 && btn->xindex<0 &&btn->xindex>-hcount)
hmap[-btn->xindex] = 1;
}
}
x=0; y=0;
done = 0;
/* search a vacant slot */
for (i=1; i<WMAX(vcount, hcount); i++) {
if (i < vcount && vmap[i]==0) {
/* found a slot */
x = 0;
y = i;
done = 1;
break;
} else if (i < hcount && hmap[i]==0) {
/* found a slot */
x = i;
y = 0;
done = 1;
break;
}
}
wfree(vmap);
wfree(hmap);
/* If found a slot, translate and return */
if (done) {
if (corner==C_NW || corner==C_NE) {
*y_pos = y;
} else {
*y_pos = -y;
}
if (corner==C_NE || corner==C_SE) {
*x_pos = x;
} else {
*x_pos = -x;
}
return True;
}
/* else, try to find a slot somewhere else */
}
/* a map of mwidth x mwidth would be enough if we allowed icons to be
* placed outside of screen */
mwidth = (int)ceil(sqrt(dock->max_icons));
/* In the worst case (the clip is in the corner of the screen),
* the amount of icons that fit in the clip is smaller.
* Double the map to get a safe value.
*/
mwidth += mwidth;
r = (mwidth-1)/2;
slot_map = wmalloc(mwidth*mwidth);
memset(slot_map, 0, mwidth*mwidth);
#define XY2OFS(x,y) (WMAX(abs(x),abs(y)) > r) ? 0 : (((y)+r)*(mwidth)+(x)+r)
/* mark used slots in the map. If the slot falls outside the map
* (for example, when all icons are placed in line), ignore them. */
for (i=0; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (btn)
slot_map[XY2OFS(btn->xindex, btn->yindex)] = 1;
}
for (chain=scr->global_icons; chain!=NULL; chain=chain->next) {
slot_map[XY2OFS(chain->aicon->xindex, chain->aicon->yindex)] = 1;
}
/* Find closest slot from the center that is free by scanning the
* map from the center to outward in circular passes.
* This will not result in a neat layout, but will be optimal
* in the sense that there will not be holes left.
*/
done = 0;
for (i = 1; i <= r && !done; i++) {
int tx, ty;
/* top and bottom parts of the ring */
for (x = -i; x <= i && !done; x++) {
tx = dock->x_pos + x*ICON_SIZE;
y = -i;
ty = dock->y_pos + y*ICON_SIZE;
if (slot_map[XY2OFS(x,y)]==0
&& ON_SCREEN(tx, ty, sx, ex, sy, ey)) {
*x_pos = x;
*y_pos = y;
done = 1;
break;
}
y = i;
ty = dock->y_pos + y*ICON_SIZE;
if (slot_map[XY2OFS(x,y)]==0
&& ON_SCREEN(tx, ty, sx, ex, sy, ey)) {
*x_pos = x;
*y_pos = y;
done = 1;
break;
}
}
/* left and right parts of the ring */
for (y = -i+1; y <= i-1; y++) {
ty = dock->y_pos + y*ICON_SIZE;
x = -i;
tx = dock->x_pos + x*ICON_SIZE;
if (slot_map[XY2OFS(x,y)]==0
&& ON_SCREEN(tx, ty, sx, ex, sy, ey)) {
*x_pos = x;
*y_pos = y;
done = 1;
break;
}
x = i;
tx = dock->x_pos + x*ICON_SIZE;
if (slot_map[XY2OFS(x,y)]==0
&& ON_SCREEN(tx, ty, sx, ex, sy, ey)) {
*x_pos = x;
*y_pos = y;
done = 1;
break;
}
}
}
wfree(slot_map);
#undef XY2OFS
return done;
}
static void
moveDock(WDock *dock, int new_x, int new_y)
{
WAppIcon *btn;
int i;
dock->x_pos = new_x;
dock->y_pos = new_y;
for (i=0; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (btn) {
btn->x_pos = new_x + btn->xindex*ICON_SIZE;
btn->y_pos = new_y + btn->yindex*ICON_SIZE;
XMoveWindow(dpy, btn->icon->core->window, btn->x_pos, btn->y_pos);
}
}
}
static void
swapDock(WDock *dock)
{
WScreen *scr = dock->screen_ptr;
WAppIcon *btn;
int x, i;
if (dock->on_right_side) {
x = dock->x_pos = scr->scr_width - ICON_SIZE - DOCK_EXTRA_SPACE;
} else {
x = dock->x_pos = DOCK_EXTRA_SPACE;
}
for (i=0; i<dock->max_icons; i++) {
btn = dock->icon_array[i];
if (btn) {
btn->x_pos = x;
XMoveWindow(dpy, btn->icon->core->window, btn->x_pos, btn->y_pos);
}
}
wScreenUpdateUsableArea(scr);
}
static pid_t
execCommand(WAppIcon *btn, char *command, WSavedState *state)
{
WScreen *scr = btn->icon->core->screen_ptr;
pid_t pid;
char **argv;
int argc;
char *cmdline;
cmdline = ExpandOptions(scr, command);
if (scr->flags.dnd_data_convertion_status || !cmdline) {
if (cmdline)
wfree(cmdline);
if (state)
wfree(state);
return 0;
}
wtokensplit(cmdline, &argv, &argc);
if (argv==NULL) {
if (cmdline)
wfree(cmdline);
if (state)
wfree(state);
return 0;
}
if ((pid=fork())==0) {
char **args;
int i;
SetupEnvironment(scr);
#ifdef HAVE_SETPGID
setpgid(0, 0);
#endif
args = malloc(sizeof(char*)*(argc+1));
if (!args)
exit(111);
for (i=0; i<argc; i++) {
args[i] = argv[i];
}
args[argc] = NULL;
execvp(argv[0], args);
exit(111);
}
wtokenfree(argv, argc);
if (pid > 0) {
if (!state) {
state = wmalloc(sizeof(WSavedState));
memset(state, 0, sizeof(WSavedState));
state->hidden = -1;
state->miniaturized = -1;
state->shaded = -1;
if (btn->dock==scr->dock || btn->omnipresent)
state->workspace = -1;
else
state->workspace = scr->current_workspace;
}
wWindowAddSavedState(btn->wm_instance, btn->wm_class, cmdline, pid,
state);
wAddDeathHandler(pid, (WDeathHandler*)trackDeadProcess,
btn->dock);
} else if (state) {
wfree(state);
}
wfree(cmdline);
return pid;
}
void
wDockHideIcons(WDock *dock)
{
int i;
if (dock==NULL)
return;
for (i=1; i<dock->max_icons; i++) {
if (dock->icon_array[i])
XUnmapWindow(dpy, dock->icon_array[i]->icon->core->window);
}
dock->mapped = 0;
dockIconPaint(dock->icon_array[0]);
}
void
wDockShowIcons(WDock *dock)
{
int i, newlevel;
WAppIcon *btn;
if (dock==NULL)
return;
btn = dock->icon_array[0];
moveDock(dock, btn->x_pos, btn->y_pos);
newlevel = dock->lowered ? WMNormalLevel : WMDockLevel;
ChangeStackingLevel(btn->icon->core, newlevel);
for (i=1; i<dock->max_icons; i++) {
if (dock->icon_array[i]) {
MoveInStackListAbove(dock->icon_array[i]->icon->core,
btn->icon->core);
break;
}
}
if (!dock->collapsed) {
for (i=1; i<dock->max_icons; i++) {
if (dock->icon_array[i]) {
XMapWindow(dpy, dock->icon_array[i]->icon->core->window);
}
}
}
dock->mapped = 1;
dockIconPaint(btn);
}
void
wDockLower(WDock *dock)
{
int i;
for (i=0; i<dock->max_icons; i++) {
if (dock->icon_array[i])
wLowerFrame(dock->icon_array[i]->icon->core);
}
}
void
wDockRaise(WDock *dock)
{
int i;
for (i=dock->max_icons-1; i>=0; i--) {
if (dock->icon_array[i])
wRaiseFrame(dock->icon_array[i]->icon->core);
}
}
void
wDockRaiseLower(WDock *dock)
{
if (!dock->icon_array[0]->icon->core->stacking->above
||(dock->icon_array[0]->icon->core->stacking->window_level
!=dock->icon_array[0]->icon->core->stacking->above->stacking->window_level))
wDockLower(dock);
else
wDockRaise(dock);
}
void
wDockFinishLaunch(WDock *dock, WAppIcon *icon)
{
icon->launching = 0;
icon->relaunching = 0;
dockIconPaint(icon);
}
WAppIcon*
wDockFindIconForWindow(WDock *dock, Window window)
{
WAppIcon *icon;
int i;
for (i=0; i<dock->max_icons; i++) {
icon = dock->icon_array[i];
if (icon && icon->main_window == window)
return icon;
}
return NULL;
}
void
wDockTrackWindowLaunch(WDock *dock, Window window)
{
WAppIcon *icon;
char *wm_class, *wm_instance;
int i;
Bool firstPass = True;
Bool found = False;
char *command = NULL;
{
int argc;
char **argv;
if (XGetCommand(dpy, window, &argv, &argc)) {
if (argc > 0 && argv != NULL)
command = wtokenjoin(argv, argc);
if (argv) {
XFreeStringList(argv);
}
}
}
if (!PropGetWMClass(window, &wm_class, &wm_instance) ||
(!wm_class && !wm_instance))
return;
retry:
for (i=0; i<dock->max_icons; i++) {
icon = dock->icon_array[i];
if (!icon)
continue;
/* app is already attached to icon */
if (icon->main_window == window) {
found = True;
break;
}
if ((icon->wm_instance || icon->wm_class)
&& (icon->launching || !icon->running)) {
if (icon->wm_instance && wm_instance &&
strcmp(icon->wm_instance, wm_instance)!=0) {
continue;
}
if (icon->wm_class && wm_class &&
strcmp(icon->wm_class, wm_class)!=0) {
continue;
}
if (firstPass && command && strcmp(icon->command, command)!=0) {
continue;
}
if (!icon->relaunching) {
WApplication *wapp;
/* Possibly an application that was docked with dockit,
* but the user did not update WMState to indicate that
* it was docked by force */
wapp = wApplicationOf(window);
if (!wapp) {
icon->forced_dock = 1;
icon->running = 0;
}
if (!icon->forced_dock)
icon->main_window = window;
}
found = True;
if (!wPreferences.no_animations && !icon->launching &&
!dock->screen_ptr->flags.startup && !dock->collapsed) {
WAppIcon *aicon;
int x0, y0;
icon->launching = 1;
dockIconPaint(icon);
aicon = wAppIconCreateForDock(dock->screen_ptr, NULL,
wm_instance, wm_class,
TILE_NORMAL);
PlaceIcon(dock->screen_ptr, &x0, &y0);
wAppIconMove(aicon, x0, y0);
/* Should this always be lowered? -Dan */
if (dock->lowered)
wLowerFrame(aicon->icon->core);
XMapWindow(dpy, aicon->icon->core->window);
aicon->launching = 1;
wAppIconPaint(aicon);
SlideWindow(aicon->icon->core->window, x0, y0,
icon->x_pos, icon->y_pos);
XUnmapWindow(dpy, aicon->icon->core->window);
wAppIconDestroy(aicon);
}
wDockFinishLaunch(dock, icon);
break;
}
}
if (firstPass && !found) {
firstPass = False;
goto retry;
}
if (command)
wfree(command);
if (wm_class)
XFree(wm_class);
if (wm_instance)
XFree(wm_instance);
}
void
wClipUpdateForWorkspaceChange(WScreen *scr, int workspace)
{
if (!wPreferences.flags.noclip) {
scr->clip_icon->dock = scr->workspaces[workspace]->clip;
if (scr->current_workspace != workspace) {
WDock *old_clip = scr->workspaces[scr->current_workspace]->clip;
WAppIconChain *chain = scr->global_icons;
while (chain) {
moveIconBetweenDocks(chain->aicon->dock,
scr->workspaces[workspace]->clip,
chain->aicon, chain->aicon->xindex,
chain->aicon->yindex);
if (scr->workspaces[workspace]->clip->collapsed)
XUnmapWindow(dpy, chain->aicon->icon->core->window);
chain = chain->next;
}
wDockHideIcons(old_clip);
if (old_clip->auto_raise_lower) {
if (old_clip->auto_raise_magic) {
WMDeleteTimerHandler(old_clip->auto_raise_magic);
old_clip->auto_raise_magic = NULL;
}
wDockLower(old_clip);
}
if (old_clip->auto_collapse) {
if (old_clip->auto_expand_magic) {
WMDeleteTimerHandler(old_clip->auto_expand_magic);
old_clip->auto_expand_magic = NULL;
}
old_clip->collapsed = 1;
}
wDockShowIcons(scr->workspaces[workspace]->clip);
}
if (scr->flags.clip_balloon_mapped)
showClipBalloon(scr->clip_icon->dock, workspace);
}
}
static void
trackDeadProcess(pid_t pid, unsigned char status, WDock *dock)
{
WAppIcon *icon;
int i;
for (i=0; i<dock->max_icons; i++) {
icon = dock->icon_array[i];
if (!icon)
continue;
if (icon->launching && icon->pid == pid) {
if (!icon->relaunching) {
icon->running = 0;
icon->main_window = None;
}
wDockFinishLaunch(dock, icon);
icon->pid = 0;
if (status==111) {
char msg[PATH_MAX];
char *cmd;
if (icon->drop_launch)
cmd = icon->dnd_command;
else if (icon->paste_launch)
cmd = icon->paste_command;
else
cmd = icon->command;
snprintf(msg, sizeof(msg),
_("Could not execute command \"%s\""), cmd);
wMessageDialog(dock->screen_ptr, _("Error"), msg,
_("OK"), NULL, NULL);
}
break;
}
}
}
static void
toggleLowered(WDock *dock)
{
WAppIcon *tmp;
int newlevel, i;
/* lower/raise Dock */
if (!dock->lowered) {
newlevel = WMNormalLevel;
dock->lowered = 1;
} else {
newlevel = WMDockLevel;
dock->lowered = 0;
}
for (i=0; i<dock->max_icons; i++) {
tmp = dock->icon_array[i];
if (!tmp)
continue;
ChangeStackingLevel(tmp->icon->core, newlevel);
if (dock->lowered)
wLowerFrame(tmp->icon->core);
}
if (dock->type == WM_DOCK)
wScreenUpdateUsableArea(dock->screen_ptr);
}
static void
toggleCollapsed(WDock *dock)
{
if (dock->collapsed) {
dock->collapsed = 0;
wDockShowIcons(dock);
}
else {
dock->collapsed = 1;
wDockHideIcons(dock);
}
}
static void
openDockMenu(WDock *dock, WAppIcon *aicon, XEvent *event)
{
WScreen *scr = dock->screen_ptr;
WObjDescriptor *desc;
WMenuEntry *entry;
WApplication *wapp = NULL;
int index = 0;
int x_pos;
int n_selected;
int appIsRunning = aicon->running && aicon->icon && aicon->icon->owner;
if (dock->type == WM_DOCK) {
/* keep on top */
entry = dock->menu->entries[index];
entry->flags.indicator_on = !dock->lowered;
entry->clientdata = dock;
dock->menu->flags.realized = 0;
} else {
/* clip options */
if (scr->clip_options)
updateClipOptionsMenu(scr->clip_options, dock);
n_selected = numberOfSelectedIcons(dock);
/* Rename Workspace */
entry = dock->menu->entries[++index];
if (aicon == scr->clip_icon) {
entry->callback = renameCallback;
entry->clientdata = dock;
entry->flags.indicator = 0;
entry->text = _("Rename Workspace");
} else {
entry->callback = omnipresentCallback;
entry->clientdata = aicon;
if (n_selected > 0) {
entry->flags.indicator = 0;
entry->text = _("Toggle Omnipresent");
} else {
entry->flags.indicator = 1;
entry->flags.indicator_on = aicon->omnipresent;
entry->flags.indicator_type = MI_CHECK;
entry->text = _("Omnipresent");
}
}
/* select/unselect icon */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
entry->flags.indicator_on = aicon->icon->selected;
wMenuSetEnabled(dock->menu, index, aicon!=scr->clip_icon);
/* select/unselect all icons */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
if (n_selected > 0)
entry->text = _("Unselect All Icons");
else
entry->text = _("Select All Icons");
wMenuSetEnabled(dock->menu, index, dock->icon_count > 1);
/* keep icon(s) */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
if (n_selected > 1)
entry->text = _("Keep Icons");
else
entry->text = _("Keep Icon");
wMenuSetEnabled(dock->menu, index, dock->icon_count > 1);
/* this is the workspace submenu part */
entry = dock->menu->entries[++index];
if (n_selected > 1)
entry->text = _("Move Icons To");
else
entry->text = _("Move Icon To");
if (scr->clip_submenu)
updateWorkspaceMenu(scr->clip_submenu, aicon);
wMenuSetEnabled(dock->menu, index, !aicon->omnipresent);
/* remove icon(s) */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
if (n_selected > 1)
entry->text = _("Remove Icons");
else
entry->text = _("Remove Icon");
wMenuSetEnabled(dock->menu, index, dock->icon_count > 1);
/* attract icon(s) */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
dock->menu->flags.realized = 0;
wMenuRealize(dock->menu);
}
if (aicon->icon->owner) {
wapp = wApplicationOf(aicon->icon->owner->main_window);
} else {
wapp = NULL;
}
/* launch */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
wMenuSetEnabled(dock->menu, index, aicon->command!=NULL);
/* unhide here */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
if (wapp && wapp->flags.hidden) {
entry->text = _("Unhide Here");
} else {
entry->text = _("Bring Here");
}
wMenuSetEnabled(dock->menu, index, appIsRunning);
/* hide */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
if (wapp && wapp->flags.hidden) {
entry->text = _("Unhide");
} else {
entry->text = _("Hide");
}
wMenuSetEnabled(dock->menu, index, appIsRunning);
/* settings */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
wMenuSetEnabled(dock->menu, index, !aicon->editing
&& !wPreferences.flags.noupdates);
/* kill */
entry = dock->menu->entries[++index];
entry->clientdata = aicon;
wMenuSetEnabled(dock->menu, index, appIsRunning);
if (!dock->menu->flags.realized)
wMenuRealize(dock->menu);
if (dock->type == WM_CLIP) {
x_pos = event->xbutton.x_root+2;
} else {
x_pos = dock->on_right_side ?
scr->scr_width - dock->menu->frame->core->width - 2 : 0;
}
wMenuMapAt(dock->menu, x_pos, event->xbutton.y_root+2, False);
/* allow drag select */
event->xany.send_event = True;
desc = &dock->menu->menu->descriptor;
(*desc->handle_mousedown)(desc, event);
}
static void
openClipWorkspaceMenu(WScreen *scr, int x, int y)
{
if (!scr->clip_ws_menu) {
scr->clip_ws_menu = wWorkspaceMenuMake(scr, False);
}
wWorkspaceMenuUpdate(scr, scr->clip_ws_menu);
wMenuMapAt(scr->clip_ws_menu, x, y, False);
}
/******************************************************************/
static void
iconDblClick(WObjDescriptor *desc, XEvent *event)
{
WAppIcon *btn = desc->parent;
WDock *dock = btn->dock;
WApplication *wapp = NULL;
int unhideHere = 0;
if (btn->icon->owner && !(event->xbutton.state & ControlMask)) {
wapp = wApplicationOf(btn->icon->owner->main_window);
assert(wapp!=NULL);
unhideHere = (event->xbutton.state & ShiftMask);
/* go to the last workspace that the user worked on the app */
if (wapp->last_workspace != dock->screen_ptr->current_workspace
&& !unhideHere) {
wWorkspaceChange(dock->screen_ptr, wapp->last_workspace);
}
wUnhideApplication(wapp, event->xbutton.button==Button2,
unhideHere);
if (event->xbutton.state & MOD_MASK) {
wHideOtherApplications(btn->icon->owner);
}
} else {
if (event->xbutton.button==Button1) {
if (event->xbutton.state & MOD_MASK) {
/* raise/lower dock */
toggleLowered(dock);
} else if (btn == dock->screen_ptr->clip_icon) {
if (getClipButton(event->xbutton.x, event->xbutton.y)==CLIP_IDLE)
toggleCollapsed(dock);
else
handleClipChangeWorkspace(dock->screen_ptr, event);
} else if (btn->command) {
if (!btn->launching &&
(!btn->running || (event->xbutton.state & ControlMask))) {
launchDockedApplication(btn, False);
}
} else if (btn->xindex == 0 && btn->yindex == 0
&& btn->dock->type == WM_DOCK) {
wShowGNUstepPanel(dock->screen_ptr);
}
}
}
}
static void
handleDockMove(WDock *dock, WAppIcon *aicon, XEvent *event)
{
WScreen *scr = dock->screen_ptr;
int ofs_x=event->xbutton.x, ofs_y=event->xbutton.y;
int x, y;
XEvent ev;
int grabbed = 0, swapped = 0, done;
Pixmap ghost = None;
int superfluous = wPreferences.superfluous; /* we catch it to avoid problems */
#ifdef DEBUG
puts("moving dock");
#endif
if (XGrabPointer(dpy, aicon->icon->core->window, True, ButtonMotionMask
|ButtonReleaseMask|ButtonPressMask, GrabModeAsync,
GrabModeAsync, None, None, CurrentTime) !=GrabSuccess) {
wwarning("pointer grab failed for dock move");
}
y = 0;
for (x=0; x<dock->max_icons; x++) {
if (dock->icon_array[x]!=NULL &&
dock->icon_array[x]->yindex > y)
y = dock->icon_array[x]->yindex;
}
y++;
XResizeWindow(dpy, scr->dock_shadow, ICON_SIZE, ICON_SIZE*y);
done = 0;
while (!done) {
WMMaskEvent(dpy, PointerMotionMask|ButtonReleaseMask|ButtonPressMask
|ButtonMotionMask|ExposureMask, &ev);
switch (ev.type) {
case Expose:
WMHandleEvent(&ev);
break;
case MotionNotify:
if (!grabbed) {
if (abs(ofs_x-ev.xmotion.x)>=MOVE_THRESHOLD
|| abs(ofs_y-ev.xmotion.y)>=MOVE_THRESHOLD) {
XChangeActivePointerGrab(dpy, ButtonMotionMask
|ButtonReleaseMask|ButtonPressMask,
wCursor[WCUR_MOVE], CurrentTime);
grabbed=1;
}
break;
}
if (dock->type == WM_CLIP) {
if (ev.xmotion.x_root - ofs_x < 0) {
x = 0;
} else if (ev.xmotion.x_root - ofs_x + ICON_SIZE >
scr->scr_width) {
x = scr->scr_width - ICON_SIZE;
} else {
x = ev.xmotion.x_root - ofs_x;
}
if (ev.xmotion.y_root - ofs_y < 0) {
y = 0;
} else if (ev.xmotion.y_root - ofs_y + ICON_SIZE >
scr->scr_height) {
y = scr->scr_height - ICON_SIZE;
} else {
y = ev.xmotion.y_root - ofs_y;
}
moveDock(dock, x, y);
} else {
/* move vertically if pointer is inside the dock*/
if ((dock->on_right_side &&
ev.xmotion.x_root >= dock->x_pos - ICON_SIZE)
|| (!dock->on_right_side &&
ev.xmotion.x_root <= dock->x_pos + ICON_SIZE*2)) {
if (ev.xmotion.y_root - ofs_y < 0) {
y = 0;
} else if (ev.xmotion.y_root - ofs_y + ICON_SIZE >
scr->scr_height) {
y = scr->scr_height - ICON_SIZE;
} else {
y = ev.xmotion.y_root - ofs_y;
}
moveDock(dock, dock->x_pos, y);
}
/* move horizontally to change sides */
x = ev.xmotion.x_root - ofs_x;
if (!dock->on_right_side) {
/* is on left */
if (ev.xmotion.x_root > dock->x_pos + ICON_SIZE*2) {
XMoveWindow(dpy, scr->dock_shadow, scr->scr_width-ICON_SIZE
-DOCK_EXTRA_SPACE-1, dock->y_pos);
if (superfluous && ghost==None) {
ghost = MakeGhostDock(dock, dock->x_pos,
scr->scr_width-ICON_SIZE
-DOCK_EXTRA_SPACE-1,
dock->y_pos);
XSetWindowBackgroundPixmap(dpy, scr->dock_shadow,
ghost);
XClearWindow(dpy, scr->dock_shadow);
}
XMapRaised(dpy, scr->dock_shadow);
swapped = 1;
} else {
if (superfluous && ghost!=None) {
XFreePixmap(dpy, ghost);
ghost = None;
}
XUnmapWindow(dpy, scr->dock_shadow);
swapped = 0;
}
} else {
/* is on right */
if (ev.xmotion.x_root < dock->x_pos - ICON_SIZE) {
XMoveWindow(dpy, scr->dock_shadow,
DOCK_EXTRA_SPACE, dock->y_pos);
if (superfluous && ghost==None) {
ghost = MakeGhostDock(dock, dock->x_pos,
DOCK_EXTRA_SPACE, dock->y_pos);
XSetWindowBackgroundPixmap(dpy, scr->dock_shadow,
ghost);
XClearWindow(dpy, scr->dock_shadow);
}
XMapRaised(dpy, scr->dock_shadow);
swapped = -1;
} else {
XUnmapWindow(dpy, scr->dock_shadow);
swapped = 0;
if (superfluous && ghost!=None) {
XFreePixmap(dpy, ghost);
ghost = None;
}
}
}
}
break;
case ButtonPress:
break;
case ButtonRelease:
if (ev.xbutton.button != event->xbutton.button)
break;
XUngrabPointer(dpy, CurrentTime);
XUnmapWindow(dpy, scr->dock_shadow);
XResizeWindow(dpy, scr->dock_shadow, ICON_SIZE, ICON_SIZE);
if (dock->type == WM_DOCK) {
if (swapped!=0) {
if (swapped>0)
dock->on_right_side = 1;
else
dock->on_right_side = 0;
swapDock(dock);
wArrangeIcons(scr, False);
}
}
done = 1;
break;
}
}
if (superfluous) {
if (ghost!=None)
XFreePixmap(dpy, ghost);
XSetWindowBackground(dpy, scr->dock_shadow, scr->white_pixel);
}
#ifdef DEBUG
puts("End dock move");
#endif
}
static void
handleIconMove(WDock *dock, WAppIcon *aicon, XEvent *event)
{
WScreen *scr = dock->screen_ptr;
Window wins[2];
WIcon *icon = aicon->icon;
WDock *dock2 = NULL, *last_dock = dock, *clip = NULL;
int ondock, grabbed = 0, change_dock = 0, collapsed = 0;
XEvent ev;
int x = aicon->x_pos, y = aicon->y_pos;
int ofs_x = event->xbutton.x, ofs_y = event->xbutton.y;
int shad_x = x, shad_y = y;
int ix = aicon->xindex, iy = aicon->yindex;
int tmp;
Pixmap ghost = None;
Bool docked;
int superfluous = wPreferences.superfluous; /* we catch it to avoid problems */
int omnipresent = aicon->omnipresent; /* this must be cached!!! */
if (wPreferences.flags.noupdates)
return;
if (XGrabPointer(dpy, icon->core->window, True, ButtonMotionMask
|ButtonReleaseMask|ButtonPressMask, GrabModeAsync,
GrabModeAsync, None, None, CurrentTime) !=GrabSuccess) {
#ifdef DEBUG0
wwarning("pointer grab failed for icon move");
#endif
}
if (!(event->xbutton.state & MOD_MASK))
wRaiseFrame(icon->core);
if (!wPreferences.flags.noclip)
clip = scr->workspaces[scr->current_workspace]->clip;
if (dock == scr->dock && !wPreferences.flags.noclip)
dock2 = clip;
else if (dock != scr->dock && !wPreferences.flags.nodock)
dock2 = scr->dock;
wins[0] = icon->core->window;
wins[1] = scr->dock_shadow;
XRestackWindows(dpy, wins, 2);
XMoveResizeWindow(dpy, scr->dock_shadow, aicon->x_pos, aicon->y_pos,
ICON_SIZE, ICON_SIZE);
if (superfluous) {
if (icon->pixmap!=None)
ghost = MakeGhostIcon(scr, icon->pixmap);
else
ghost = MakeGhostIcon(scr, icon->core->window);
XSetWindowBackgroundPixmap(dpy, scr->dock_shadow, ghost);
XClearWindow(dpy, scr->dock_shadow);
}
XMapWindow(dpy, scr->dock_shadow);
ondock = 1;
while(1) {
XMaskEvent(dpy, PointerMotionMask|ButtonReleaseMask|ButtonPressMask
|ButtonMotionMask|ExposureMask, &ev);
switch (ev.type) {
case Expose:
WMHandleEvent(&ev);
break;
case MotionNotify:
if (!grabbed) {
if (abs(ofs_x-ev.xmotion.x)>=MOVE_THRESHOLD
|| abs(ofs_y-ev.xmotion.y)>=MOVE_THRESHOLD) {
XChangeActivePointerGrab(dpy, ButtonMotionMask
|ButtonReleaseMask|ButtonPressMask,
wCursor[WCUR_MOVE], CurrentTime);
grabbed=1;
} else {
break;
}
}
if (omnipresent) {
int i;
for (i=0; i<scr->workspace_count; i++) {
if (i == scr->current_workspace)
continue;
wDockShowIcons(scr->workspaces[i]->clip);
}
}
x = ev.xmotion.x_root - ofs_x;
y = ev.xmotion.y_root - ofs_y;
tmp = wDockSnapIcon(dock, aicon, x, y, &ix, &iy, True);
if (tmp && dock2) {
change_dock = 0;
if (last_dock != dock && collapsed) {
last_dock->collapsed = 1;
wDockHideIcons(last_dock);
collapsed = 0;
}
if (!collapsed && (collapsed = dock->collapsed)) {
dock->collapsed = 0;
wDockShowIcons(dock);
}
if (dock->auto_raise_lower)
wDockRaise(dock);
last_dock = dock;
} else if (dock2) {
tmp = wDockSnapIcon(dock2, aicon, x, y, &ix, &iy, False);
if (tmp) {
change_dock = 1;
if (last_dock != dock2 && collapsed) {
last_dock->collapsed = 1;
wDockHideIcons(last_dock);
collapsed = 0;
}
if (!collapsed && (collapsed = dock2->collapsed)) {
dock2->collapsed = 0;
wDockShowIcons(dock2);
}
if (dock2->auto_raise_lower)
wDockRaise(dock2);
last_dock = dock2;
}
}
if (aicon->launching
|| aicon->lock
|| (aicon->running && !(ev.xmotion.state & MOD_MASK))
|| (!aicon->running && tmp)) {
shad_x = last_dock->x_pos + ix*wPreferences.icon_size;
shad_y = last_dock->y_pos + iy*wPreferences.icon_size;
XMoveWindow(dpy, scr->dock_shadow, shad_x, shad_y);
if (!ondock) {
XMapWindow(dpy, scr->dock_shadow);
}
ondock = 1;
} else {
if (ondock) {
XUnmapWindow(dpy, scr->dock_shadow);
}
ondock = 0;
}
XMoveWindow(dpy, icon->core->window, x, y);
break;
case ButtonPress:
break;
case ButtonRelease:
if (ev.xbutton.button != event->xbutton.button)
break;
XUngrabPointer(dpy, CurrentTime);
if (ondock) {
SlideWindow(icon->core->window, x, y, shad_x, shad_y);
XUnmapWindow(dpy, scr->dock_shadow);
if (!change_dock) {
reattachIcon(dock, aicon, ix, iy);
if (clip && dock!=clip && clip->auto_raise_lower)
wDockLower(clip);
} else {
docked = moveIconBetweenDocks(dock, dock2, aicon, ix, iy);
if (!docked) {
/* Slide it back if dock rejected it */
SlideWindow(icon->core->window, x, y, aicon->x_pos,
aicon->y_pos);
reattachIcon(dock, aicon, aicon->xindex,aicon->yindex);
}
if (last_dock->type==WM_CLIP && last_dock->auto_collapse) {
collapsed = 0;
}
}
} else {
aicon->x_pos = x;
aicon->y_pos = y;
if (superfluous) {
if (!aicon->running && !wPreferences.no_animations) {
/* We need to deselect it, even if is deselected in
* wDockDetach(), because else DoKaboom() will fail.
*/
if (aicon->icon->selected)
wIconSelect(aicon->icon);
wSoundPlay(WSOUND_KABOOM);
DoKaboom(scr,aicon->icon->core->window, x, y);
} else {
wSoundPlay(WSOUND_UNDOCK);
}
} else {
wSoundPlay(WSOUND_UNDOCK);
}
if (clip && clip->auto_raise_lower)
wDockLower(clip);
wDockDetach(dock, aicon);
}
if (collapsed) {
last_dock->collapsed = 1;
wDockHideIcons(last_dock);
collapsed = 0;
}
if (superfluous) {
if (ghost!=None)
XFreePixmap(dpy, ghost);
XSetWindowBackground(dpy, scr->dock_shadow, scr->white_pixel);
}
if (omnipresent) {
int i;
for (i=0; i<scr->workspace_count; i++) {
if (i == scr->current_workspace)
continue;
wDockHideIcons(scr->workspaces[i]->clip);
}
}
#ifdef DEBUG
puts("End icon move");
#endif
return;
}
}
}
static int
getClipButton(int px, int py)
{
int pt = (CLIP_BUTTON_SIZE+2)*ICON_SIZE/64;
if (px < 0 || py < 0 || px >= ICON_SIZE || py >= ICON_SIZE)
return CLIP_IDLE;
if (py <= pt-((int)ICON_SIZE-1-px))
return CLIP_FORWARD;
else if (px <= pt-((int)ICON_SIZE-1-py))
return CLIP_REWIND;
return CLIP_IDLE;
}
static void
handleClipChangeWorkspace(WScreen *scr, XEvent *event)
{
XEvent ev;
int done, direction, new_ws;
int new_dir;
WDock *clip = scr->clip_icon->dock;
direction = getClipButton(event->xbutton.x, event->xbutton.y);
clip->lclip_button_pushed = direction==CLIP_REWIND;
clip->rclip_button_pushed = direction==CLIP_FORWARD;
wClipIconPaint(scr->clip_icon);
done = 0;
while(!done) {
WMMaskEvent(dpy, ExposureMask|ButtonMotionMask|ButtonReleaseMask
|ButtonPressMask, &ev);
switch (ev.type) {
case Expose:
WMHandleEvent(&ev);
break;
case MotionNotify:
new_dir = getClipButton(ev.xmotion.x, ev.xmotion.y);
if (new_dir != direction) {
direction = new_dir;
clip->lclip_button_pushed = direction==CLIP_REWIND;
clip->rclip_button_pushed = direction==CLIP_FORWARD;
wClipIconPaint(scr->clip_icon);
}
break;
case ButtonPress:
break;
case ButtonRelease:
if (ev.xbutton.button == event->xbutton.button)
done = 1;
}
}
clip->lclip_button_pushed = 0;
clip->rclip_button_pushed = 0;
new_ws = wPreferences.ws_advance || (event->xbutton.state & ControlMask);
if (direction == CLIP_FORWARD) {
if (scr->current_workspace < scr->workspace_count-1)
wWorkspaceChange(scr, scr->current_workspace+1);
else if (new_ws && scr->current_workspace < MAX_WORKSPACES-1)
wWorkspaceChange(scr, scr->current_workspace+1);
else if (wPreferences.ws_cycle)
wWorkspaceChange(scr, 0);
}
else if (direction == CLIP_REWIND) {
if (scr->current_workspace > 0)
wWorkspaceChange(scr, scr->current_workspace-1);
else if (scr->current_workspace==0 && wPreferences.ws_cycle)
wWorkspaceChange(scr, scr->workspace_count-1);
}
wClipIconPaint(scr->clip_icon);
}
static void
iconMouseDown(WObjDescriptor *desc, XEvent *event)
{
WAppIcon *aicon = desc->parent;
WDock *dock = aicon->dock;
WScreen *scr = aicon->icon->core->screen_ptr;
if (aicon->editing || WCHECK_STATE(WSTATE_MODAL))
return;
scr->last_dock = dock;
if (dock->menu->flags.mapped)
wMenuUnmap(dock->menu);
if (IsDoubleClick(scr, event)) {
/* double-click was not in the main clip icon */
if (dock->type != WM_CLIP || aicon->xindex!=0 || aicon->yindex!=0
|| getClipButton(event->xbutton.x, event->xbutton.y)==CLIP_IDLE) {
iconDblClick(desc, event);
return;
}
}
if (dock->type == WM_CLIP && scr->flags.clip_balloon_mapped) {
XUnmapWindow(dpy, scr->clip_balloon);
scr->flags.clip_balloon_mapped = 0;
}
#ifdef DEBUG
puts("handling dock");
#endif
if (event->xbutton.button == Button1) {
if (event->xbutton.state & MOD_MASK)
wDockLower(dock);
else
wDockRaise(dock);
if ((event->xbutton.state & ShiftMask) && aicon!=scr->clip_icon &&
dock->type!=WM_DOCK) {
wIconSelect(aicon->icon);
return;
}
if (aicon->yindex==0 && aicon->xindex==0) {
if (getClipButton(event->xbutton.x, event->xbutton.y)!=CLIP_IDLE
&& dock->type==WM_CLIP)
handleClipChangeWorkspace(scr, event);
else
handleDockMove(dock, aicon, event);
} else
handleIconMove(dock, aicon, event);
} else if (event->xbutton.button==Button2 && dock->type==WM_CLIP &&
aicon==scr->clip_icon) {
openClipWorkspaceMenu(scr, event->xbutton.x_root+2,
event->xbutton.y_root+2);
if (scr->clip_ws_menu) {
WMenu *menu;
menu = scr->clip_ws_menu;
desc = &menu->menu->descriptor;
event->xany.send_event = True;
(*desc->handle_mousedown)(desc, event);
}
} else if (event->xbutton.button==Button2 && dock->type==WM_CLIP &&
(event->xbutton.state & ShiftMask) && aicon!=scr->clip_icon) {
wClipMakeIconOmnipresent(aicon, !aicon->omnipresent);
} else if (event->xbutton.button == Button3) {
if (event->xbutton.send_event &&
XGrabPointer(dpy, aicon->icon->core->window, True, ButtonMotionMask
|ButtonReleaseMask|ButtonPressMask, GrabModeAsync,
GrabModeAsync, None, None, CurrentTime) !=GrabSuccess) {
wwarning("pointer grab failed for dockicon menu");
return;
}
openDockMenu(dock, aicon, event);
} else if (event->xbutton.button == Button2) {
WAppIcon *btn = desc->parent;
if (!btn->launching &&
(!btn->running || (event->xbutton.state & ControlMask))) {
launchDockedApplication(btn, True);
}
}
}
static void
showClipBalloon(WDock *dock, int workspace)
{
int w, h;
int x, y;
WScreen *scr = dock->screen_ptr;
char *text;
Window stack[2];
scr->flags.clip_balloon_mapped = 1;
XMapWindow(dpy, scr->clip_balloon);
text = scr->workspaces[workspace]->name;
w = WMWidthOfString(scr->clip_title_font, text, strlen(text));
h = WMFontHeight(scr->clip_title_font);
XResizeWindow(dpy, scr->clip_balloon, w, h);
x = dock->x_pos + CLIP_BUTTON_SIZE*ICON_SIZE/64;
y = dock->y_pos + ICON_SIZE - WMFontHeight(scr->clip_title_font) - 3;
if (x+w > scr->scr_width) {
x = scr->scr_width - w;
if (dock->y_pos + ICON_SIZE + h > scr->scr_height)
y = dock->y_pos - h - 1;
else
y = dock->y_pos + ICON_SIZE;
XRaiseWindow(dpy, scr->clip_balloon);
} else {
stack[0] = scr->clip_icon->icon->core->window;
stack[1] = scr->clip_balloon;
XRestackWindows(dpy, stack, 2);
}
XMoveWindow(dpy, scr->clip_balloon, x, y);
XSetForeground(dpy, scr->clip_title_gc,
scr->clip_title_pixel[CLIP_NORMAL]);
XClearWindow(dpy, scr->clip_balloon);
WMDrawString(scr->wmscreen, scr->clip_balloon, scr->clip_title_gc,
scr->clip_title_font, 0, 0, text, strlen(text));
}
static void
clipEnterNotify(WObjDescriptor *desc, XEvent *event)
{
WAppIcon *btn = (WAppIcon*)desc->parent;
WDock *dock;
WScreen *scr;
assert(event->type==EnterNotify);
if(desc->parent_type!=WCLASS_DOCK_ICON)
return;
scr = btn->icon->core->screen_ptr;
if (!btn->omnipresent)
dock = btn->dock;
else
dock = scr->workspaces[scr->current_workspace]->clip;
if (!dock || dock->type!=WM_CLIP)
return;
/* The auto raise/lower code */
if (dock->auto_lower_magic) {
WMDeleteTimerHandler(dock->auto_lower_magic);
dock->auto_lower_magic = NULL;
}
if (dock->auto_raise_lower && !dock->auto_raise_magic) {
dock->auto_raise_magic = WMAddTimerHandler(AUTO_RAISE_DELAY,
clipAutoRaise,
(void *)dock);
}
/* The auto expand/collapse code */
if (dock->auto_collapse_magic) {
WMDeleteTimerHandler(dock->auto_collapse_magic);
dock->auto_collapse_magic = NULL;
}
if (dock->auto_collapse && !dock->auto_expand_magic) {
dock->auto_expand_magic = WMAddTimerHandler(AUTO_EXPAND_DELAY,
clipAutoExpand,
(void *)dock);
}
if (btn->xindex == 0 && btn->yindex == 0)
showClipBalloon(dock, dock->screen_ptr->current_workspace);
else {
if (dock->screen_ptr->flags.clip_balloon_mapped) {
XUnmapWindow(dpy, dock->screen_ptr->clip_balloon);
dock->screen_ptr->flags.clip_balloon_mapped = 0;
}
}
}
static void
clipLeave(WDock *dock)
{
XEvent event;
WObjDescriptor *desc = NULL;
if (!dock || dock->type!=WM_CLIP)
return;
if (XCheckTypedEvent(dpy, EnterNotify, &event)!=False) {
if (XFindContext(dpy, event.xcrossing.window, wWinContext,
(XPointer *)&desc)!=XCNOENT
&& desc && desc->parent_type==WCLASS_DOCK_ICON
&& ((WAppIcon*)desc->parent)->dock
&& ((WAppIcon*)desc->parent)->dock->type==WM_CLIP) {
/* We didn't left the Clip yet */
XPutBackEvent(dpy, &event);
return;
}
XPutBackEvent(dpy, &event);
} else {
/* We entered a withdrawn window, so we're still in Clip */
return;
}
if (dock->auto_raise_magic) {
WMDeleteTimerHandler(dock->auto_raise_magic);
dock->auto_raise_magic = NULL;
}
if (dock->auto_raise_lower && !dock->auto_lower_magic) {
dock->auto_lower_magic = WMAddTimerHandler(AUTO_LOWER_DELAY,
clipAutoLower,
(void *)dock);
}
if (dock->auto_expand_magic) {
WMDeleteTimerHandler(dock->auto_expand_magic);
dock->auto_expand_magic = NULL;
}
if (dock->auto_collapse && !dock->auto_collapse_magic) {
dock->auto_collapse_magic = WMAddTimerHandler(AUTO_COLLAPSE_DELAY,
clipAutoCollapse,
(void *)dock);
}
}
static void
clipLeaveNotify(WObjDescriptor *desc, XEvent *event)
{
WAppIcon *btn = (WAppIcon*)desc->parent;
assert(event->type==LeaveNotify);
if(desc->parent_type!=WCLASS_DOCK_ICON)
return;
clipLeave(btn->dock);
}
static void
clipAutoCollapse(void *cdata)
{
WDock *dock = (WDock *)cdata;
if (dock->type!=WM_CLIP)
return;
if (dock->auto_collapse) {
dock->collapsed = 1;
wDockHideIcons(dock);
}
dock->auto_collapse_magic = NULL;
}
static void
clipAutoExpand(void *cdata)
{
WDock *dock = (WDock *)cdata;
if (dock->type!=WM_CLIP)
return;
if (dock->auto_collapse) {
dock->collapsed = 0;
wDockShowIcons(dock);
}
dock->auto_expand_magic = NULL;
}
static void
clipAutoLower(void *cdata)
{
WDock *dock = (WDock *)cdata;
if (dock->type!=WM_CLIP)
return;
if (dock->auto_raise_lower)
wDockLower(dock);
dock->auto_lower_magic = NULL;
}
static void
clipAutoRaise(void *cdata)
{
WDock *dock = (WDock *)cdata;
if (dock->type!=WM_CLIP)
return;
if (dock->auto_raise_lower)
wDockRaise(dock);
if (dock->screen_ptr->flags.clip_balloon_mapped) {
showClipBalloon(dock, dock->screen_ptr->current_workspace);
}
dock->auto_raise_magic = NULL;
}
static Bool
iconCanBeOmnipresent(WAppIcon *aicon)
{
WScreen *scr = aicon->icon->core->screen_ptr;
WDock *clip;
WAppIcon *btn;
int i, j;
for (i=0; i<scr->workspace_count; i++) {
clip = scr->workspaces[i]->clip;
if (clip == aicon->dock)
continue;
if (clip->icon_count + scr->global_icon_count >= clip->max_icons)
return False; /* Clip is full in some workspace */
for (j=0; j<clip->max_icons; j++) {
btn = clip->icon_array[j];
if(btn && btn->xindex==aicon->xindex && btn->yindex==aicon->yindex)
return False;
}
}
return True;
}
int
wClipMakeIconOmnipresent(WAppIcon *aicon, int omnipresent)
{
WScreen *scr = aicon->icon->core->screen_ptr;
WAppIconChain *new_entry, *tmp, *tmp1;
int status = WO_SUCCESS;
if ((scr->dock && aicon->dock==scr->dock) || aicon==scr->clip_icon) {
return WO_NOT_APPLICABLE;
}
if (aicon->omnipresent == omnipresent)
return WO_SUCCESS;
if (omnipresent) {
if (iconCanBeOmnipresent(aicon)) {
aicon->omnipresent = 1;
new_entry = wmalloc(sizeof(WAppIconChain));
new_entry->aicon = aicon;
new_entry->next = scr->global_icons;
scr->global_icons = new_entry;
scr->global_icon_count++;
} else {
aicon->omnipresent = 0;
status = WO_FAILED;
}
} else {
aicon->omnipresent = 0;
if (aicon == scr->global_icons->aicon) {
tmp = scr->global_icons->next;
wfree(scr->global_icons);
scr->global_icons = tmp;
scr->global_icon_count--;
} else {
tmp = scr->global_icons;
while (tmp->next) {
if (tmp->next->aicon == aicon) {
tmp1 = tmp->next->next;
wfree(tmp->next);
tmp->next = tmp1;
scr->global_icon_count--;
break;
}
tmp = tmp->next;
}
}
}
wAppIconPaint(aicon);
return status;
}
Reference in New Issue View Git Blame Copy Permalink