/*************************************<->*************************************
*
* wspSetPosition (pPres)
*
*
* Description:
* -----------
* Sets the position of the workspace presence dialog
*
* Inputs:
* ------
* pPres = pointer to workspace presence data
*
* Outputs:
* --------
*
******************************<->***********************************/
static void
wspSetPosition(
PtrWsPresenceData pPres )
{
WmScreenData *pSD = pPres->pCDforClient->pSD;
Arg args[10];
int n;
XFontStruct *font;
Dimension height;
int x, y;
/*
* Get size of this dialog
*/
n = 0;
XtSetArg (args[n], XmNheight, &height); n++;
XtGetValues (pPres->shellW, args, n);
if (wmGD.positionIsFrame)
{
if (pSD->decoupleTitleAppearance)
{
font = pSD->clientTitleAppearance.font;
}
else
{
font = pSD->clientAppearance.font;
}
height += TEXT_HEIGHT(font) + (2 * pSD->frameBorderWidth);
}
/*
* set position of dialog relative to client window
* (use system menu position)
* set this dialog to be transient for the client
* for which it is posted.
*/
GetSystemMenuPosition (pPres->pCDforClient,
&x, &y, height,
pPres->contextForClient);
n = 0;
XtSetArg (args[n], XmNx, x); n++;
XtSetArg (args[n], XmNy, y); n++;
XtSetArg (args[n], XmNtransientFor, NULL); n++;
if (pPres->contextForClient != F_CONTEXT_ICON)
{
XtSetArg (args[n], XmNwindowGroup, pPres->pCDforClient->client); n++;
}
else if (pSD->useIconBox && P_ICON_BOX(pPres->pCDforClient))
{
XtSetArg (args[n], XmNwindowGroup,
P_ICON_BOX(pPres->pCDforClient)->pCD_iconBox->client); n++;
}
else
{
XtSetArg (args[n], XmNwindowGroup, 0); n++;
}
XtSetArg (args[n], XmNwaitForWm, False); n++;
XtSetValues (pPres->shellW, args, n);
} /* END OF FUNCTION wspSetPosition */
static void SetupWindowStateWithEventMask (ClientData *pCD, int newState,
Time setTime, unsigned int event_mask)
{
int currentState;
#ifdef WSM
int wsI, iplace;
WmWorkspaceData *pWS_i;
#else /* WSM */
WmWorkspaceData *pWS = PSD_FOR_CLIENT(pCD)->pActiveWS;
#endif /* WSM */
WmScreenData *pSD = PSD_FOR_CLIENT(pCD);
currentState = pCD->clientState;
/*
* A transient window is not restored or maximized if the transient leader
* is minimized.
*/
if (newState == NORMAL_STATE)
{
if (pCD->maxConfig == True)
{
/*
* The configuration function uses maxConfig to determine
* what the current configuration is (and then resets
* maxConfig) and uses the state paramenter to determine
* what the new configuration is.
*/
ConfigureNewState (pCD);
}
}
else /* MAXIMIZED_STATE */
{
if (pCD->maxConfig == False)
{
ConfigureNewState (pCD);
}
}
if (currentState == MINIMIZED_STATE)
{
Boolean clearIconFocus;
/*
* give up keyboard focus
*/
if ((wmGD.keyboardFocus == pCD) ||
(wmGD.nextKeyboardFocus == pCD))
{
Do_Focus_Key (NULL, setTime, ALWAYS_SET_FOCUS | WORKSPACE_IF_NULL);
}
if (wmGD.keyboardFocus == pCD)
{
clearIconFocus = True;
}
else
{
clearIconFocus = False;
}
/*
* The wm icon frame window and the client icon window
* (if it is being used) are mapped and the client window and
* client frame are unmapped.
*/
if (ICON_FRAME_WIN(pCD))
{
if (pSD->useIconBox && P_ICON_BOX(pCD) &&
!(pCD->clientFlags & ICON_BOX))
{
ShowClientIconState(pCD, newState);
}
else
{
Boolean doGrab = False;
if (event_mask)
doGrab = (Success == XGrabPointer
(DISPLAY, DefaultRootWindow(DISPLAY),
False, event_mask, GrabModeAsync, GrabModeAsync,
None, None, CurrentTime));
XUnmapWindow (DISPLAY, ICON_FRAME_WIN(pCD));
if (pCD->iconWindow)
{
XUnmapWindow (DISPLAY, pCD->iconWindow);
}
if (event_mask && doGrab)
{
XEvent event;
XMaskEvent(DISPLAY, event_mask, &event);
XUngrabPointer(DISPLAY,CurrentTime);
}
#ifdef WSM
if (wmGD.iconAutoPlace)
{
for (wsI = 0; wsI < pCD->numInhabited; wsI++)
{
iplace = pCD->pWsList[wsI].iconPlace;
if (iplace != NO_ICON_PLACE)
{
pWS_i = GetWorkspaceData (pCD->pSD,
pCD->pWsList[wsI].wsID);
pWS_i->IPData.placeList[iplace].pCD =
NULL;
}
}
}
#else /* WSM */
if ((wmGD.iconAutoPlace) && (ICON_PLACE(pCD) != NO_ICON_PLACE))
{
pWS->IPData.placeList[ICON_PLACE(pCD)].pCD =
NULL;
}
#endif /* WSM */
}
if (clearIconFocus)
{
ClearFocusIndication (pCD, False /*no refresh*/);
wmGD.keyboardFocus = NULL;
}
}
}
if ((currentState != NORMAL_STATE) && (currentState != MAXIMIZED_STATE))
{
/*
* Note that maximized state is considered a NormalState in
* the ICCC. SetClientWMState also sets the state in the
* client data.
*/
if (currentState == MINIMIZED_STATE)
{
/*
* Raise the window(s) when they are deiconified.
*/
pCD->clientState = newState;
#ifdef WSM
wmGD.bSuspendSecondaryRestack = True;
#endif /* WSM */
F_Raise (NULL, pCD, NULL);
#ifdef WSM
wmGD.bSuspendSecondaryRestack = False;
#endif /* WSM */
}
if ( (!(pCD->clientFlags & ICON_BOX)) ||
((pCD->clientFlags & ICON_BOX) && (!(firstTime))) )
{
#ifdef PANELIST
if ((currentState == WITHDRAWN_STATE) &&
(pCD->dtwmBehaviors & DtWM_BEHAVIOR_SUBPANEL) &&
!(pCD->transientChildren))
{
if (pCD->dtwmBehaviors & DtWM_BEHAVIOR_SUB_RESTORED)
{
pCD->dtwmBehaviors &= ~DtWM_BEHAVIOR_SUB_RESTORED;
pCD->dtwmBehaviors &= ~DtWM_BEHAVIOR_SUBPANEL;
XMapWindow (DISPLAY, pCD->client);
XMapWindow (DISPLAY, pCD->clientFrameWin);
}
else
{
SlideWindowOut (pCD);
}
}
else
#endif /* PANELIST */
MapClientWindows (pCD);
}
/*
* Set the WM_STATE property of the window and any associated
* transients, along with the clientState value. The call
* is made with an indication of NORMAL_STATE to insure
* that transient window clientState values are setup
* correctly. The top-level window clientState is set later.
*/
SetClientWMState (pCD, NormalState, NORMAL_STATE);
}
pCD->clientState = newState;
if ((wmGD.keyboardFocusPolicy == KEYBOARD_FOCUS_EXPLICIT) &&
(currentState == MINIMIZED_STATE) && wmGD.deiconifyKeyFocus)
{
ClientData *pcdFocus;
pcdFocus = FindTransientFocus (pCD);
if (pcdFocus)
{
Do_Focus_Key (pcdFocus, setTime, ALWAYS_SET_FOCUS);
}
}
if ( pSD->useIconBox && P_ICON_BOX(pCD) &&
(!(pCD->clientFlags & ICON_BOX)) && (ICON_FRAME_WIN(pCD)))
{
/*
* force icon appearance in icon box to change
*/
IconExposureProc (pCD, True);
}
} /* END OF FUNCTION SetupWindowStateWithEventMask */
void SetClientStateWithEventMask (ClientData *pCD, int newState, Time setTime, unsigned int event_mask)
{
ClientData *pcdLeader;
int currentState;
WmScreenData *pSD = PSD_FOR_CLIENT(pCD);
#ifdef WSM
Boolean notShowing = (newState & UNSEEN_STATE);
#endif /* WSM */
currentState = pCD->clientState;
if (currentState == newState)
{
/* no change in state */
return;
}
/*
* Undo the old state and setup the new state. If this is a transient
* window then insure that it is put in a state that is compatible
* with its transient leader (e.g., it cannot be minimized separately).
*/
pcdLeader = (pCD->transientLeader) ? FindTransientTreeLeader (pCD) : pCD;
#ifdef WSM
SetClientWsIndex (pCD);
#endif /* WSM */
if (pCD->transientLeader)
{
if ((pcdLeader->clientState == MINIMIZED_STATE) &&
(newState != WITHDRAWN_STATE))
{
newState = MINIMIZED_STATE;
#ifdef WSM
if (notShowing)
{
newState |= UNSEEN_STATE;
}
#endif /* WSM */
}
else if ((newState == MINIMIZED_STATE) &&
(pcdLeader->clientState != MINIMIZED_STATE))
{
if (currentState == WITHDRAWN_STATE)
{
newState = NORMAL_STATE;
#ifdef WSM
if (notShowing)
{
newState |= UNSEEN_STATE;
}
#endif /* WSM */
}
else
{
newState = currentState;
#ifdef WSM
if (notShowing)
{
newState |= UNSEEN_STATE;
}
#endif /* WSM */
}
}
if (newState == currentState)
{
return;
}
}
switch (newState)
{
#ifdef WSM
case UNSEEN_STATE | WITHDRAWN_STATE:
#else
case WITHDRAWN_STATE:
#endif /* WSM */
{
/*
* Free window manager resources (frame and icon). The
* WM_STATE property is set in WithdrawWindow.
*/
UnManageWindow (pCD);
break;
}
case NORMAL_STATE:
case MAXIMIZED_STATE:
{
SetupWindowStateWithEventMask (pCD, newState, setTime, event_mask);
#ifdef WSM
XMapWindow (DISPLAY, pCD->client);
XMapWindow (DISPLAY, pCD->clientFrameWin);
#if defined(PANELIST)
WmStopWaiting(); /* in WmIPC.c */
#endif /* PANELIST */
#endif /* WSM */
break;
}
case MINIMIZED_STATE:
{
Boolean clientHasFocus;
/*
* Transient windows are minimized with the rest of the transient
* tree, including the transient leader.
*/
if ((pCD->clientState == NORMAL_STATE) ||
(pCD->clientState == MAXIMIZED_STATE))
{
if ((wmGD.keyboardFocus == pCD) ||
(pCD->transientChildren && wmGD.keyboardFocus &&
(pCD == FindTransientTreeLeader (wmGD.keyboardFocus))))
{
clientHasFocus = True;
}
else
{
clientHasFocus = False;
}
if (clientHasFocus ||
((wmGD.nextKeyboardFocus == pCD) ||
(pCD->transientChildren && wmGD.keyboardFocus &&
(pCD == FindTransientTreeLeader (wmGD.nextKeyboardFocus)))))
{
/*
* Give up the keyboard focus when minimized (including
* the case in which an associated transient window has
* the focus). Immediately remove the focus indication
* from the window being minimized.
*/
if (wmGD.autoKeyFocus &&
(wmGD.keyboardFocusPolicy == KEYBOARD_FOCUS_EXPLICIT))
{
AutoResetKeyFocus (pcdLeader, setTime);
}
else
{
Do_Focus_Key (NULL, setTime,
ALWAYS_SET_FOCUS | WORKSPACE_IF_NULL);
}
if (clientHasFocus)
{
SetKeyboardFocus (NULL, 0);
}
}
/* unmap main client and all transients */
UnmapClients (pCD, event_mask);
}
/*
* Display the icon for the minimized client.
*/
if (ICON_FRAME_WIN(pCD))
{
#ifdef WSM
if (pCD->clientState & UNSEEN_STATE)
{
if (pCD->iconWindow)
{
XMapWindow (DISPLAY, pCD->iconWindow);
}
XMapWindow (DISPLAY, ICON_FRAME_WIN(pCD));
}
ShowAllIconsForMinimizedClient (pCD);
#else /* WSM */
ShowIconForMinimizedClient (pSD->pActiveWS, pCD);
#endif /* WSM */
}
SetClientWMState (pCD, IconicState, MINIMIZED_STATE);
if ((pSD->useIconBox) && P_ICON_BOX(pCD))
{
if ((pCD->clientFlags & ICON_BOX) && ACTIVE_ICON_TEXT_WIN)
{
/*
* Hide active icon text window and reparent it to
* root
*/
HideActiveIconText((WmScreenData *)NULL);
pSD->activeLabelParent = ACTIVE_ROOT;
XReparentWindow(DISPLAY, ACTIVE_ICON_TEXT_WIN ,
ACTIVE_ROOT, 0, 0 );
}
if (ICON_FRAME_WIN(pCD))
{
/*
* force icon appearance in icon box to change
*/
IconExposureProc (pCD, True);
}
}
break;
}
#ifdef WSM
case UNSEEN_STATE | NORMAL_STATE:
case UNSEEN_STATE | MAXIMIZED_STATE:
case UNSEEN_STATE | MINIMIZED_STATE:
{
if (wmGD.keyboardFocus == pCD)
{
/*
* Give up the keyboard focus
*/
Do_Focus_Key ((ClientData *)NULL,
CurrentTime, ALWAYS_SET_FOCUS);
SetKeyboardFocus (NULL, 0);
}
if (!(pCD->clientState & UNSEEN_STATE) &&
(((pCD->clientState & ~UNSEEN_STATE) == NORMAL_STATE) ||
((pCD->clientState & ~UNSEEN_STATE) == MAXIMIZED_STATE)))
{
/* unmap main client and all transients */
UnmapClients (pcdLeader, event_mask);
}
if (pCD->clientFrameWin)
{
if (!P_ICON_BOX(pCD))
{
if (ICON_FRAME_WIN(pCD))
{
XUnmapWindow (DISPLAY, ICON_FRAME_WIN(pCD));
}
if (pCD->iconWindow)
XUnmapWindow (DISPLAY, pCD->iconWindow);
}
}
switch (newState & ~UNSEEN_STATE)
{
case MINIMIZED_STATE:
SetClientWMState (pCD, IconicState, newState);
break;
case NORMAL_STATE:
case MAXIMIZED_STATE:
default:
SetClientWMState (pCD, NormalState, newState);
break;
}
}
break;
#endif /* WSM */
}
} /* END OF FUNCTION SetClientStateWithEventMask */
void ShowIconForMinimizedClient (WmWorkspaceData *pWS, ClientData *pCD)
{
WmScreenData *pSD = PSD_FOR_CLIENT(pCD);
/*
* Handle auto-placement for root icons (icons not in an icon
* box).
*/
if (wmGD.iconAutoPlace && !P_ICON_BOX(pCD))
{
if ((ICON_PLACE(pCD) == NO_ICON_PLACE) ||
((pWS->IPData.placeList[ICON_PLACE(pCD)].pCD) &&
(pWS->IPData.placeList[ICON_PLACE(pCD)].pCD != pCD)))
{
/*
* Icon place not defined or occupied by another client,
* find a free place to put the icon.
*/
if ((ICON_PLACE(pCD) = GetNextIconPlace (&pWS->IPData))
== NO_ICON_PLACE)
{
ICON_PLACE(pCD) =
CvtIconPositionToPlace (&pWS->IPData,
pCD->clientX,
pCD->clientY);
}
CvtIconPlaceToPosition (&pWS->IPData, ICON_PLACE(pCD),
&ICON_X(pCD), &ICON_Y(pCD));
#ifndef WSM
XMoveWindow (DISPLAY, ICON_FRAME_WIN(pCD),
ICON_X(pCD), ICON_Y(pCD));
#endif /* WSM */
}
pWS->IPData.placeList[ICON_PLACE(pCD)].pCD = pCD;
}
#ifdef WSM
/*
* If icon on root window and this workspace is active, the
* make sure it's in the right place.
*/
if ((pWS == pSD->pActiveWS) && !P_ICON_BOX(pCD))
{
XMoveWindow (DISPLAY, ICON_FRAME_WIN(pCD),
ICON_X(pCD), ICON_Y(pCD));
}
#endif /* WSM */
if (pCD->iconWindow)
{
XMapWindow (DISPLAY, pCD->iconWindow);
}
if ((pSD->useIconBox) && P_ICON_BOX(pCD))
{
ShowClientIconState (pCD, MINIMIZED_STATE );
}
else
{
XWindowChanges windowChanges;
/*
* Map the icon on the screen at the appropriate place in the
* window stack.
*/
if (wmGD.lowerOnIconify)
{
if ((&pCD->iconEntry != pSD->lastClient) &&
(pSD->lastClient))
{
if (pSD->lastClient->type == MINIMIZED_STATE)
{
windowChanges.sibling =
ICON_FRAME_WIN(pSD->lastClient->pCD);
}
else
{
windowChanges.sibling =
pSD->lastClient->pCD->clientFrameWin;
}
windowChanges.stack_mode = Below;
XConfigureWindow (DISPLAY, ICON_FRAME_WIN(pCD),
(CWSibling | CWStackMode), &windowChanges);
MoveEntryInList (pWS, &pCD->iconEntry,
False /*on bottom*/, NULL);
}
}
else
{
windowChanges.sibling = pCD->clientFrameWin;
windowChanges.stack_mode = Below;
XConfigureWindow (DISPLAY, ICON_FRAME_WIN(pCD),
(CWSibling | CWStackMode), &windowChanges);
MoveEntryInList (pWS, &pCD->iconEntry, False /*below*/,
&pCD->clientEntry);
}
#ifdef WSM
if (pWS == pSD->pActiveWS)
{
XMapWindow (DISPLAY, ICON_FRAME_WIN(pCD));
}
#else /* WSM */
XMapWindow (DISPLAY, ICON_FRAME_WIN(pCD));
#endif /* WSM */
}
} /* END OF FUNCTION ShowIconForMinimizedClient */
int FindIconPlace (ClientData *pCD, IconPlacementData *pIPD, int x, int y)
{
int place;
int i;
int j;
int diffX;
int diffY;
int altX;
int altY;
int amt;
place = CvtIconPositionToPlace (pIPD, x, y);
if (place < pIPD->totalPlaces)
{
if (pIPD->placeList[place].pCD == (ClientData *)NULL)
{
return (place);
}
}
else
{
if (pIPD->iconPlacement & ICON_PLACE_LEFT_PRIMARY)
{
amt = pIPD->placementCols; /* add a new row */
}
else
{
amt = pIPD->placementRows; /* add a new column */
}
if (!ExtendIconList (P_ICON_BOX(pCD), amt))
{
Warning (((char *)GETMESSAGE(34, 4, "Insufficient memory to create icon box data")));
return (NO_ICON_PLACE);
}
}
/*
* The place for the passed in position is in use, look at places for
* alternative positions.
*/
for (i = 0; i < 2; i++)
{
switch (i)
{
case 0:
{
diffX = ICON_WIDTH(pCD) / 2;
diffY = ICON_HEIGHT(pCD) / 2;
break;
}
case 1:
{
diffX = pIPD->iPlaceW / 2;
diffY = pIPD->iPlaceH / 2;
break;
}
}
for (j = 0; j < 4; j++)
{
switch (j)
{
case 0:
{
if (pIPD->iconPlacement & ICON_PLACE_LEFT_PRIMARY)
{
altX = x - diffX;
altY = y;
}
else if (pIPD->iconPlacement & ICON_PLACE_RIGHT_PRIMARY)
{
altX = x + diffX;
altY = y;
}
else if (pIPD->iconPlacement & ICON_PLACE_TOP_PRIMARY)
{
altX = x;
altY = y - diffY;
}
else
{
altX = x;
altY = y + diffY;
}
break;
}
case 1:
{
if (pIPD->iconPlacement & ICON_PLACE_LEFT_PRIMARY)
{
altX = x + diffX;
altY = y;
}
else if (pIPD->iconPlacement & ICON_PLACE_RIGHT_PRIMARY)
{
altX = x - diffX;
altY = y;
}
else if (pIPD->iconPlacement & ICON_PLACE_TOP_PRIMARY)
{
altX = x;
altY = y + diffY;
}
else
{
altX = x;
altY = y - diffY;
}
break;
}
case 2:
{
if (pIPD->iconPlacement & ICON_PLACE_LEFT_SECONDARY)
{
altX = x - diffX;
altY = y;
}
else if (pIPD->iconPlacement & ICON_PLACE_RIGHT_SECONDARY)
{
altX = x + diffX;
altY = y;
}
else if (pIPD->iconPlacement & ICON_PLACE_TOP_SECONDARY)
{
altX = x;
altY = y + diffY;
}
else
{
altX = x;
altY = y - diffY;
}
break;
}
case 3:
{
if (pIPD->iconPlacement & ICON_PLACE_LEFT_SECONDARY)
{
altX = x + diffX;
altY = y;
}
else if (pIPD->iconPlacement & ICON_PLACE_RIGHT_SECONDARY)
{
altX = x - diffX;
altY = y;
}
else if (pIPD->iconPlacement & ICON_PLACE_TOP_SECONDARY)
{
altX = x;
altY = y - diffY;
}
else
{
altX = x;
altY = y + diffY;
}
break;
}
}
if (P_ICON_BOX(pCD))
{
GetClipDimensions(pCD, False);
if (altX < clipX)
{
return (NO_ICON_PLACE);
}
if (altY < clipY)
{
return (NO_ICON_PLACE);
}
if (((int)altX) > ((int)clipX +
(int)clipWidth - ((int)ICON_WIDTH(pCD))))
{
return (NO_ICON_PLACE);
}
if (((int)altY) > ((int)clipY +
(int)clipHeight - ((int)ICON_HEIGHT(pCD))))
{
return (NO_ICON_PLACE);
}
}
place = CvtIconPositionToPlace (pIPD, altX, altY);
if ((pIPD->placeList[place].pCD) == NULL)
{
return (place);
}
}
}
/*
* Couldn't find an unoccupied place in the proximity of the passed-in
* position.
*/
return (NO_ICON_PLACE);
} /* END OF FUNCTION FindIconPlace */
