void CHyperLink::PreSubclassWindow()
{
// If the URL string is empty try to set it to the window text
if (m_strURL.IsEmpty())
GetWindowText(m_strURL);
// Check that the window text isn't empty.
// If it is, set it as URL string.
CString strWndText;
GetWindowText(strWndText);
if (strWndText.IsEmpty()) {
// Set the URL string as the window text
//ASSERT(!m_strURL.IsEmpty()); // window text and URL both NULL!
CStatic::SetWindowText(m_strURL);
}
// Get the current window font
CFont* pFont = GetFont();
if (pFont != NULL) {
LOGFONT lf;
pFont->GetLogFont(&lf);
lf.lfUnderline = BITSET(m_dwStyle, StyleUnderline);
if (m_Font.CreateFontIndirect(&lf))
CStatic::SetFont(&m_Font);
// Adjust window size to fit URL if necessary
AdjustWindow();
}
else {
// if GetFont() returns NULL then probably the static
// control is not of a text type: it's better to set
// auto-resizing off
CLEARBITS(m_dwStyle,StyleAutoSize);
}
if (!BITSET(m_dwStyle,StyleNoHandCursor))
SetDefaultCursor(); // Try to load an "hand" cursor
// Create the tooltip
CRect rect;
GetClientRect(rect);
m_ToolTip.Create(this);
m_ToolTip.AddTool(this, m_strURL, rect, TOOLTIP_ID);
CStatic::PreSubclassWindow();
}
void CHyperLink::PreSubclassWindow()
{
// Enable notifications - CStatic has this disabled by default
DWORD dwStyle = GetStyle();
::SetWindowLong(GetSafeHwnd(), GWL_STYLE, dwStyle | SS_NOTIFY);
// By default use the label text as the URL
if (m_strURL.IsEmpty())
GetWindowText(m_strURL);
CString strWndText;
GetWindowText(strWndText);
if (strWndText.IsEmpty())
{
SetWindowText(m_strURL);
}
CFont* pFont = GetFont();
if (!pFont)
{
HFONT hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
if (hFont == NULL)
hFont = (HFONT) GetStockObject(ANSI_VAR_FONT);
if (hFont)
pFont = CFont::FromHandle(hFont);
}
ASSERT(pFont->GetSafeHandle());
LOGFONT lf;
pFont->GetLogFont(&lf);
m_StdFont.CreateFontIndirect(&lf);
lf.lfUnderline = (BYTE) TRUE;
m_UnderlineFont.CreateFontIndirect(&lf);
SetDefaultCursor(); // try loading a "hand" cursor
SetUnderline();
CRect rect;
GetClientRect(rect);
m_ToolTip.Create(this);
m_ToolTip.AddTool(this, m_strURL, rect, TOOLTIP_ID);
CStatic::PreSubclassWindow();
}
/** Stop move. */
void StopMove(ClientNode *np, int doMove,
int oldx, int oldy, MaxFlags maxFlags)
{
int north, south, east, west;
Assert(np);
Assert(np->controller);
(np->controller)(0);
np->controller = NULL;
SetDefaultCursor(np->parent);
UnregisterCallback(SignalMove, NULL);
if(!doMove) {
np->x = oldx;
np->y = oldy;
/* Restore maximized status. */
if(maxFlags) {
MaximizeClient(np, maxFlags);
}
return;
}
GetBorderSize(&np->state, &north, &south, &east, &west);
if(np->parent != None) {
JXMoveWindow(display, np->parent, np->x - west, np->y - north);
} else {
JXMoveWindow(display, np->window, np->x - west, np->y - north);
}
SendConfigureEvent(np);
/* Restore maximized status. */
if(maxFlags) {
MaximizeClient(np, maxFlags);
}
}
/** Stop move. */
void StopMove(ClientNode *np, int doMove,
int oldx, int oldy, int hmax, int vmax)
{
int north, south, east, west;
Assert(np);
Assert(np->controller);
(np->controller)(0);
np->controller = NULL;
SetDefaultCursor(np->parent);
UnregisterCallback(SignalMove, NULL);
if(!doMove) {
np->x = oldx;
np->y = oldy;
/* Restore maximized status if only maximized in one direction. */
if((hmax || vmax) && !(hmax && vmax)) {
MaximizeClient(np, hmax, vmax);
}
return;
}
GetBorderSize(&np->state, &north, &south, &east, &west);
JXMoveWindow(display, np->parent, np->x - west, np->y - north);
SendConfigureEvent(np);
/* Restore maximized status. */
if((hmax || vmax) && !(hmax && vmax)) {
MaximizeClient(np, hmax, vmax);
}
}
void CHyperLink::PreSubclassWindow()
{
// Enable notifications - CStatic has this disabled by default
ModifyStyle(0, SS_NOTIFY);
// By default use the label text as the URL
if (m_strURL.IsEmpty())
GetWindowText(m_strURL);
CString strWndText;
GetWindowText(strWndText);
if (strWndText.IsEmpty())
{
SetWindowText(m_strURL);
}
LOGFONT lf;
CFont* pFont = GetFont();
if (pFont)
pFont->GetObject(sizeof(lf), &lf);
else
{
NONCLIENTMETRICS metrics = { 0 };
metrics.cbSize = sizeof(NONCLIENTMETRICS);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &metrics, FALSE);
memcpy_s(&lf, sizeof(LOGFONT), &metrics.lfMessageFont, sizeof(LOGFONT));
}
m_StdFont.CreateFontIndirect(&lf);
lf.lfUnderline = TRUE;
m_UnderlineFont.CreateFontIndirect(&lf);
SetDefaultCursor(); // try loading a "hand" cursor
SetUnderline();
CRect rect;
GetClientRect(rect);
m_ToolTip.Create(this);
m_ToolTip.AddTool(this, m_strURL, rect, TOOLTIP_ID);
CStatic::PreSubclassWindow();
}
/** Process an enter notify event. */
void HandleEnterNotify(const XCrossingEvent *event)
{
ClientNode *np;
Cursor cur;
np = FindClient(event->window);
if(np) {
if( !(np->state.status & STAT_ACTIVE)
&& (settings.focusModel == FOCUS_SLOPPY)) {
FocusClient(np);
}
if(np->parent == event->window) {
np->borderAction = GetBorderActionType(np, event->x, event->y);
cur = GetFrameCursor(np->borderAction);
JXDefineCursor(display, np->parent, cur);
} else if(np->borderAction != BA_NONE) {
SetDefaultCursor(np->parent);
np->borderAction = BA_NONE;
}
}
}
void CHyperLink::PreSubclassWindow()
{
// We want to get mouse clicks via STN_CLICKED
DWORD dwStyle = GetStyle();
::SetWindowLong(GetSafeHwnd(), GWL_STYLE, dwStyle | SS_NOTIFY);
// Set the URL as the window text
if (m_strURL.IsEmpty())
GetWindowText(m_strURL);
// Check that the window text isn't empty. If it is, set it as the URL.
CString strWndText;
GetWindowText(strWndText);
if (strWndText.IsEmpty())
{
ASSERT(!m_strURL.IsEmpty()); // Window and URL both NULL. DUH!
SetWindowText(m_strURL);
}
m_pStdFont = GetFont();
ASSERT(m_pStdFont);
// Create the underline font
LOGFONT lf;
m_pStdFont->GetLogFont(&lf);
lf.lfUnderline = (BYTE) TRUE;
m_UnderlineFont.CreateFontIndirect(&lf);
PositionWindow(); // Adjust size of window to fit URL if necessary
SetDefaultCursor(); // Try and load up a "hand" cursor
SetUnderline();
// Create the tooltip
CRect rect;
GetClientRect(rect);
m_ToolTip.Create(this);
m_ToolTip.AddTool(this, m_strURL, rect, TOOLTIP_ID);
CStatic::PreSubclassWindow();
}
/*
PreSubclassWindow()
*/
void CHyperLink::PreSubclassWindow(void)
{
// we want to get mouse clicks via STN_CLICKED
DWORD dwStyle = GetStyle();
::SetWindowLong(GetSafeHwnd(),GWL_STYLE,dwStyle|SS_NOTIFY);
// check that the window text isn't empty. If it is, set it as the URL.
if(m_strText.IsEmpty() && m_bAutoText)
m_strText = m_strUrl;
SetWindowText(m_strText);
// create the font
LOGFONT lf;
GetFont()->GetLogFont(&lf);
lf.lfUnderline = (BYTE)m_bUnderline;
m_Font.CreateFontIndirect(&lf);
SetFont(&m_Font);
// adjust size of window to fit URL if necessary
if(m_bAdjustToFit)
PositionWindow();
// try and load up a "hand" cursor
SetDefaultCursor();
// crea il tooltip
m_wndToolTip.Create(this,TTS_ALWAYSTIP);
m_wndToolTip.SetWidth(TOOLTIP_XXL_WIDTH);
m_wndToolTip.SetDelay(TOOLTIP_REASONABLE_DELAYTIME);
CRect rect(0,0,0,0);
m_wndToolTip.AddRectTool(this,"hyperlink",&rect,ID_TOOLTIP_CONTROL);
m_wndToolTip.UpdateTipText(m_strToolTipText,this,ID_TOOLTIP_CONTROL);
GetClientRect(rect);
m_wndToolTip.SetToolRect(this,ID_TOOLTIP_CONTROL,&rect);
m_wndToolTip.Activate(TRUE);
CStatic::PreSubclassWindow();
}
void CStaticHyperLink::PreSubclassWindow()
{
DWORD dwStyle = GetStyle();
::SetWindowLongPtr(GetSafeHwnd(), GWL_STYLE, dwStyle | SS_NOTIFY);
m_crBackGround = ::GetSysColor(COLOR_BTNFACE);
SetFont();
if (m_strURL.IsEmpty())
{
GetWindowText(m_strURL.GetBuffer(MAX_PATH), MAX_PATH);
m_strURL.ReleaseBuffer();
m_strURL.Trim();
}
CString strWndText;
GetWindowText(strWndText.GetBuffer(MAX_PATH), MAX_PATH);
strWndText.ReleaseBuffer();
strWndText.Trim();
if (strWndText.IsEmpty())
{
ASSERT(!m_strURL.IsEmpty());
SetWindowText(m_strURL);
}
//PositionWindow();
SetDefaultCursor();
// Create the tooltip
CRect rect;
GetClientRect(rect);
m_ToolTip.Create(this);
m_ToolTip.AddTool(this, m_strURL, rect, TOOLTIP_ID);
CStatic::PreSubclassWindow();
}
/** Move a client window. */
char MoveClient(ClientNode *np, int startx, int starty, int snap)
{
XEvent event;
int oldx, oldy;
int doMove;
int north, south, east, west;
int height;
int hmax, vmax;
Assert(np);
if(!(np->state.border & BORDER_MOVE)) {
return 0;
}
if(np->state.status & STAT_FULLSCREEN) {
return 0;
}
GrabMouseForMove();
RegisterCallback(0, SignalMove, NULL);
np->controller = MoveController;
shouldStopMove = 0;
oldx = np->x;
oldy = np->y;
vmax = 0;
hmax = 0;
if(!(GetMouseMask() & (Button1Mask | Button2Mask))) {
StopMove(np, 0, oldx, oldy, 0, 0);
return 0;
}
GetBorderSize(&np->state, &north, &south, &east, &west);
startx -= west;
starty -= north;
currentClient = np;
atTop = 0;
atBottom = 0;
atLeft = 0;
atRight = 0;
doMove = 0;
for(;;) {
WaitForEvent(&event);
if(shouldStopMove) {
np->controller = NULL;
SetDefaultCursor(np->parent);
UnregisterCallback(SignalMove, NULL);
return doMove;
}
switch(event.type) {
case ButtonRelease:
if(event.xbutton.button == Button1
|| event.xbutton.button == Button2) {
StopMove(np, doMove, oldx, oldy, hmax, vmax);
return doMove;
}
break;
case MotionNotify:
DiscardMotionEvents(&event, np->window);
np->x = event.xmotion.x_root - startx;
np->y = event.xmotion.y_root - starty;
GetCurrentTime(&moveTime);
atLeft = 0;
atTop = 0;
atRight = 0;
atBottom = 0;
if(event.xmotion.x_root == 0) {
atLeft = 1;
} else if(event.xmotion.x_root == rootWidth - 1) {
atRight = 1;
}
if(event.xmotion.y_root == 0) {
atTop = 1;
} else if(event.xmotion.y_root == rootHeight - 1) {
atBottom = 1;
}
if(snap) {
DoSnap(np);
}
if(!doMove && (abs(np->x - oldx) > MOVE_DELTA
|| abs(np->y - oldy) > MOVE_DELTA)) {
if(np->state.status & (STAT_HMAX | STAT_VMAX)) {
if(np->state.status & STAT_HMAX) {
hmax = 1;
}
if(np->state.status & STAT_VMAX) {
vmax = 1;
}
MaximizeClient(np, 0, 0);
startx = np->width / 2;
starty = -north / 2;
MoveMouse(np->parent, startx, starty);
}
CreateMoveWindow(np);
doMove = 1;
}
if(doMove) {
if(settings.moveMode == MOVE_OUTLINE) {
ClearOutline();
height = north + south;
if(!(np->state.status & STAT_SHADED)) {
height += np->height;
}
DrawOutline(np->x - west, np->y - north,
np->width + west + east, height);
} else {
JXMoveWindow(display, np->parent, np->x - west,
np->y - north);
SendConfigureEvent(np);
}
UpdateMoveWindow(np);
UpdatePager();
}
break;
default:
break;
}
}
}
TestWidget::TestWidget
(
const JBoolean isMaster,
const JBoolean isImage,
JXMenuBar* menuBar,
JXScrollbarSet* scrollbarSet,
JXContainer* enclosure,
const HSizingOption hSizing,
const VSizingOption vSizing,
const JCoordinate x,
const JCoordinate y,
const JCoordinate w,
const JCoordinate h
)
:
JXScrollableWidget(scrollbarSet, enclosure, hSizing, vSizing, x,y, w,h),
itsRNG()
{
JIndex i;
itsFillFlag = kJFalse;
itsRandPointCount = 10;
itsResizeDialog = NULL;
SetBackColor(GetColormap()->GetDefaultBackColor());
// cursors
JXDisplay* display = GetDisplay();
itsTrekCursor = display->CreateBuiltInCursor("XC_trek", XC_trek);
itsGumbyCursor = display->CreateBuiltInCursor("XC_gumby", XC_gumby);
itsBogosityCursor = display->CreateBuiltInCursor("XC_bogosity", XC_bogosity);
itsFleurCursor = display->CreateBuiltInCursor("XC_fleur", XC_fleur);
SetDefaultCursor(itsTrekCursor);
// menus
itsActionsMenu = menuBar->AppendTextMenu(kActionsMenuTitleStr);
itsActionsMenu->SetTitleFontStyle(GetColormap()->GetWhiteColor());
itsActionsMenu->SetShortcuts(kActionsMenuShortcutStr);
itsActionsMenu->SetMenuItems(kActionsMenuStr);
itsActionsMenu->SetUpdateAction(JXMenu::kDisableNone);
ListenTo(itsActionsMenu);
itsPointMenu = jnew JXTextMenu(itsActionsMenu, kPointMenuCmd, menuBar);
assert( itsPointMenu != NULL );
itsPointMenu->SetMenuItems(kPointMenuStr);
itsPointMenu->SetUpdateAction(JXMenu::kDisableNone);
ListenTo(itsPointMenu);
// This tests the JX response to an empty menu.
JXTextMenu* emptyMenu = jnew JXTextMenu(itsActionsMenu, kEmptyMenuCmd, menuBar);
assert( emptyMenu != NULL );
JXMenu* prevMenu = itsActionsMenu;
JIndex prevMenuIndex = kAdviceMenuCmd;
for (i=1; i<=kAdviceMenuCount; i++)
{
JXTextMenu* adviceMenu = jnew JXTextMenu(prevMenu, prevMenuIndex, menuBar);
assert( adviceMenu != NULL );
adviceMenu->SetMenuItems(kAdviceMenuStr[i-1]);
adviceMenu->SetUpdateAction(JXMenu::kDisableNone);
if (i == kAdviceBoldMenuIndex)
{
adviceMenu->SetItemFontStyle(2,
JFontStyle(kJTrue, kJFalse, 0, kJFalse, GetColormap()->GetBlackColor()));
}
prevMenu = adviceMenu;
prevMenuIndex = 2;
}
BuildXlsfontsMenu(itsActionsMenu, menuBar);
// secret menus are a bad idea because the user can't find them!
itsSecretMenu = jnew JXTextMenu("", this, kFixedLeft, kFixedTop, 0,0, 10,10);
assert( itsSecretMenu != NULL );
itsSecretMenu->SetMenuItems(kSecretMenuStr);
itsSecretMenu->SetUpdateAction(JXMenu::kDisableNone);
itsSecretMenu->SetToHiddenPopupMenu(kJTrue); // will assert() otherwise
itsSecretMenu->Hide();
ListenTo(itsSecretMenu);
itsSecretSubmenu = jnew JXTextMenu(itsSecretMenu, kSecretSubmenuIndex, this);
assert( itsSecretSubmenu != NULL );
itsSecretSubmenu->SetMenuItems(kSecretSubmenuStr);
itsSecretSubmenu->SetUpdateAction(JXMenu::kDisableNone);
// we don't ListenTo() it because it's only there for show
// image from xpm
itsXPMImage = jnew JXImage(GetDisplay(), JXPM(macapp_xpm));
assert( itsXPMImage != NULL );
// partial image from image
itsPartialXPMImage = jnew JXImage(*itsXPMImage, JRect(5,5,14,16));
assert( itsPartialXPMImage != NULL );
// home symbol
itsHomeImage = jnew JXImage(GetDisplay(), JXPM(home_xpm));
assert( itsHomeImage != NULL );
itsHomeRect = itsHomeImage->GetBounds();
itsHomeRect.Shift(120, 10);
// buffer contents of Widget in JXImage
itsImageBuffer = NULL;
if (isImage)
{
CreateImageBuffer();
}
// initial size
SetBounds(400,400);
// enclosed objects
itsAnimButton =
jnew JXTextButton("Start", this, JXWidget::kFixedLeft, JXWidget::kFixedTop,
37,175, 50,30);
assert( itsAnimButton != NULL );
itsAnimButton->SetShortcuts("#A");
ListenTo(itsAnimButton);
if (isMaster)
{
itsQuitButton =
jnew JXTextButton(JGetString("Quit::TestWidget"), this, JXWidget::kFixedRight, JXWidget::kFixedBottom,
x,y, 50,30);
assert( itsQuitButton != NULL );
JXColormap* colormap = GetColormap();
itsQuitButton->CenterWithinEnclosure(kJTrue, kJTrue);
itsQuitButton->SetFontStyle(JFontStyle(kJTrue, kJFalse, 0, kJFalse, colormap->GetRedColor()));
itsQuitButton->SetNormalColor(colormap->GetCyanColor());
itsQuitButton->SetPushedColor(colormap->GetBlueColor());
ListenTo(itsQuitButton);
}
else
{
itsQuitButton = NULL;
}
ExpandToFitContent();
// drops on iconfied window
JXWindowIcon* windowIcon;
const JBoolean hasIconWindow = GetWindow()->GetIconWidget(&windowIcon);
assert( hasIconWindow );
ListenTo(windowIcon);
}
/*
SetCursor()
*/
void CHyperLink::SetCursor(HCURSOR hCursor)
{
m_hCursor = hCursor;
if(!m_hCursor)
SetDefaultCursor();
}
/** Move a client window (keyboard or menu initiated). */
char MoveClientKeyboard(ClientNode *np)
{
XEvent event;
int oldx, oldy;
int moved;
int height;
int north, south, east, west;
MaxFlags maxFlags;
Assert(np);
if(!(np->state.border & BORDER_MOVE)) {
return 0;
}
if(np->state.status & STAT_FULLSCREEN) {
return 0;
}
maxFlags = np->state.maxFlags;
if(np->state.maxFlags != MAX_NONE) {
MaximizeClient(np, MAX_NONE);
}
if(JUNLIKELY(JXGrabKeyboard(display, np->parent, True, GrabModeAsync,
GrabModeAsync, CurrentTime))) {
Debug("MoveClient: could not grab keyboard");
return 0;
}
GrabMouseForMove();
GetBorderSize(&np->state, &north, &south, &east, &west);
oldx = np->x;
oldy = np->y;
RegisterCallback(0, SignalMove, NULL);
np->controller = MoveController;
shouldStopMove = 0;
CreateMoveWindow(np);
UpdateMoveWindow(np);
MoveMouse(rootWindow, np->x, np->y);
DiscardMotionEvents(&event, np->window);
if(np->state.status & STAT_SHADED) {
height = 0;
} else {
height = np->height;
}
for(;;) {
WaitForEvent(&event);
if(shouldStopMove) {
np->controller = NULL;
SetDefaultCursor(np->parent);
UnregisterCallback(SignalMove, NULL);
return 1;
}
moved = 0;
if(event.type == KeyPress) {
DiscardKeyEvents(&event, np->window);
switch(GetKey(&event.xkey) & 0xFF) {
case KEY_UP:
if(np->y + height > 0) {
np->y -= 10;
}
break;
case KEY_DOWN:
if(np->y < rootHeight) {
np->y += 10;
}
break;
case KEY_RIGHT:
if(np->x < rootWidth) {
np->x += 10;
}
break;
case KEY_LEFT:
if(np->x + np->width > 0) {
np->x -= 10;
}
break;
default:
StopMove(np, 1, oldx, oldy, maxFlags);
return 1;
}
MoveMouse(rootWindow, np->x, np->y);
DiscardMotionEvents(&event, np->window);
moved = 1;
} else if(event.type == MotionNotify) {
DiscardMotionEvents(&event, np->window);
np->x = event.xmotion.x;
np->y = event.xmotion.y;
moved = 1;
} else if(event.type == ButtonRelease) {
StopMove(np, 1, oldx, oldy, maxFlags);
return 1;
}
if(moved) {
if(settings.moveMode == MOVE_OUTLINE) {
ClearOutline();
DrawOutline(np->x - west, np->y - west,
np->width + west + east, height + north + west);
} else {
JXMoveWindow(display, np->parent, np->x - west, np->y - north);
SendConfigureEvent(np);
}
UpdateMoveWindow(np);
RequirePagerUpdate();
}
}
}
/** Add a window to management. */
ClientNode *AddClientWindow(Window w, char alreadyMapped, char notOwner)
{
XWindowAttributes attr;
ClientNode *np;
Assert(w != None);
/* Get window attributes. */
if(JXGetWindowAttributes(display, w, &attr) == 0) {
return NULL;
}
/* Determine if we should care about this window. */
if(attr.override_redirect == True) {
return NULL;
}
if(attr.class == InputOnly) {
return NULL;
}
/* Prepare a client node for this window. */
np = Allocate(sizeof(ClientNode));
memset(np, 0, sizeof(ClientNode));
np->window = w;
np->owner = None;
np->state.desktop = currentDesktop;
np->x = attr.x;
np->y = attr.y;
np->width = attr.width;
np->height = attr.height;
np->cmap = attr.colormap;
np->state.status = STAT_NONE;
np->state.maxFlags = MAX_NONE;
np->state.layer = LAYER_NORMAL;
np->state.defaultLayer = LAYER_NORMAL;
np->state.border = BORDER_DEFAULT;
np->borderAction = BA_NONE;
ReadClientInfo(np, alreadyMapped);
if(!notOwner) {
np->state.border = BORDER_OUTLINE | BORDER_TITLE | BORDER_MOVE;
np->state.status |= STAT_WMDIALOG | STAT_STICKY;
np->state.layer = LAYER_ABOVE;
np->state.defaultLayer = LAYER_ABOVE;
}
ApplyGroups(np);
if(np->icon == NULL) {
LoadIcon(np);
}
/* We now know the layer, so insert */
np->prev = NULL;
np->next = nodes[np->state.layer];
if(np->next) {
np->next->prev = np;
} else {
nodeTail[np->state.layer] = np;
}
nodes[np->state.layer] = np;
SetDefaultCursor(np->window);
ReparentClient(np, notOwner);
PlaceClient(np, alreadyMapped);
if(!((np->state.status & STAT_FULLSCREEN) || np->state.maxFlags)) {
int north, south, east, west;
GetBorderSize(&np->state, &north, &south, &east, &west);
if(np->parent != None) {
JXMoveResizeWindow(display, np->parent, np->x - west, np->y - north,
np->width + east + west,
np->height + north + south);
JXMoveResizeWindow(display, np->window, west, north,
np->width, np->height);
} else {
JXMoveResizeWindow(display, np->window, np->x, np->y,
np->width, np->height);
}
}
/* If one of these fails we are SOL, so who cares. */
XSaveContext(display, np->window, clientContext, (void*)np);
if(np->parent != None) {
XSaveContext(display, np->parent, frameContext, (void*)np);
}
if(np->state.status & STAT_MAPPED) {
JXMapWindow(display, np->window);
if(np->parent != None) {
JXMapWindow(display, np->parent);
}
}
clientCount += 1;
if(!alreadyMapped) {
RaiseClient(np);
}
if(np->state.status & STAT_OPACITY) {
SetOpacity(np, np->state.opacity, 1);
} else {
SetOpacity(np, settings.inactiveClientOpacity, 1);
}
if(np->state.status & STAT_STICKY) {
SetCardinalAtom(np->window, ATOM_NET_WM_DESKTOP, ~0UL);
} else {
SetCardinalAtom(np->window, ATOM_NET_WM_DESKTOP, np->state.desktop);
}
/* Shade the client if requested. */
if(np->state.status & STAT_SHADED) {
np->state.status &= ~STAT_SHADED;
ShadeClient(np);
}
/* Minimize the client if requested. */
if(np->state.status & STAT_MINIMIZED) {
np->state.status &= ~STAT_MINIMIZED;
MinimizeClient(np, 0);
}
/* Maximize the client if requested. */
if(np->state.maxFlags) {
const MaxFlags flags = np->state.maxFlags;
np->state.maxFlags = MAX_NONE;
MaximizeClient(np, flags);
}
if(np->state.status & STAT_URGENT) {
RegisterCallback(URGENCY_DELAY, SignalUrgent, np);
}
/* Update task bars. */
AddClientToTaskBar(np);
/* Make sure we're still in sync */
WriteState(np);
SendConfigureEvent(np);
/* Hide the client if we're not on the right desktop. */
if(np->state.desktop != currentDesktop
&& !(np->state.status & STAT_STICKY)) {
HideClient(np);
}
ReadClientStrut(np);
/* Focus transients if their parent has focus. */
if(np->owner != None) {
if(activeClient && np->owner == activeClient->window) {
FocusClient(np);
}
}
/* Make the client fullscreen if requested. */
if(np->state.status & STAT_FULLSCREEN) {
np->state.status &= ~STAT_FULLSCREEN;
SetClientFullScreen(np, 1);
}
ResetBorder(np);
return np;
}
BOOL CXScrollBar::CreateFromStatic(DWORD dwStyle,
CWnd* pParentWnd,
UINT nIdStatic,
UINT nId)
{
TRACE(_T("in CXScrollBar::CreateFromStatic\n"));
m_pParent = pParentWnd;
ASSERT(m_pParent);
ASSERT(::IsWindow(pParentWnd->GetDlgItem(nIdStatic)->m_hWnd));
CRect rect;
pParentWnd->GetDlgItem(nIdStatic)->GetWindowRect(&rect);
pParentWnd->ScreenToClient(&rect);
// hide placeholder STATIC
pParentWnd->GetDlgItem(nIdStatic)->ShowWindow(SW_HIDE);
// load hand cursor
SetDefaultCursor();
m_bHorizontal = (dwStyle & SBS_VERT) ? FALSE : TRUE;
BOOL bResult = CStatic::Create(_T(""), dwStyle, rect, pParentWnd, nId);
if (bResult)
{
CBitmap bitmap;
// we assume that width of thumb is same as width of arrows
if (bitmap.LoadBitmap(m_bHorizontal ?
IDB_HORIZONTAL_SCROLLBAR_THUMB :
IDB_VERTICAL_SCROLLBAR_THUMB))
{
BITMAP bm;
bitmap.GetBitmap(&bm);
m_nBitmapWidth = bm.bmWidth;
m_nBitmapHeight = bm.bmHeight;
TRACE(_T("m_nBitmapWidth=%d m_nBitmapHeight=%d\n"),
m_nBitmapWidth, m_nBitmapHeight);
GetClientRect(&m_rectClient);
TRACE(_T("m_rectClient: %d, %d, %d, %d\n"),
m_rectClient.left, m_rectClient.top,
m_rectClient.right, m_rectClient.bottom);
if (bitmap.GetSafeHandle())
{
bitmap.DeleteObject();
}
}
else
{
TRACE(_T("ERROR - failed to load thumb bitmap\n"));
ASSERT(FALSE);
}
}
else
{
TRACE(_T("ERROR - failed to create CXScrollBar\n"));
ASSERT(FALSE);
}
return bResult;
}
/** Startup the various JWM components.
* This is called after the X connection is opened.
*/
void Startup(void)
{
/* This order is important. */
/* First we grab the server to prevent clients from changing things
* while we're still loading. */
GrabServer();
StartupSettings();
StartupScreens();
StartupGroups();
StartupColors();
StartupIcons();
StartupBackgrounds();
StartupFonts();
StartupCursors();
StartupPager();
StartupClock();
StartupTaskBar();
StartupTrayButtons();
StartupDesktops();
StartupHints();
StartupDock();
StartupTray();
StartupKeys();
StartupBorders();
StartupPlacement();
StartupClients();
# ifndef DISABLE_CONFIRM
StartupDialogs();
# endif
StartupPopup();
StartupRootMenu();
SetDefaultCursor(rootWindow);
ReadCurrentDesktop();
JXFlush(display);
RequireRestack();
/* Allow clients to do their thing. */
JXSync(display, True);
UngrabServer();
StartupSwallow();
DrawTray();
/* Send expose events. */
ExposeCurrentDesktop();
/* Draw the background (if backgrounds are used). */
LoadBackground(currentDesktop);
/* Run any startup commands. */
StartupCommands();
}
void CHyperLink::SetLinkCursor(HCURSOR hCursor)
{
m_hLinkCursor = hCursor;
if (m_hLinkCursor == NULL)
SetDefaultCursor();
}
/** Startup trays. */
void StartupTray(void)
{
XSetWindowAttributes attr;
Atom atom;
unsigned long attrMask;
TrayType *tp;
TrayComponentType *cp;
int variableSize;
int variableRemainder;
int width, height;
int xoffset, yoffset;
for(tp = trays; tp; tp = tp->next) {
LayoutTray(tp, &variableSize, &variableRemainder);
/* Create the tray window. */
/* The window is created larger for a border. */
attrMask = CWOverrideRedirect;
attr.override_redirect = True;
/* We can't use PointerMotionHintMask since the exact position
* of the mouse on the tray is important for popups. */
attrMask |= CWEventMask;
attr.event_mask
= ButtonPressMask
| ButtonReleaseMask
| SubstructureNotifyMask
| ExposureMask
| KeyPressMask
| KeyReleaseMask
| EnterWindowMask
| PointerMotionMask;
attrMask |= CWBackPixel;
attr.background_pixel = colors[COLOR_TRAY_BG2];
attrMask |= CWBorderPixel;
attr.border_pixel = colors[COLOR_TRAY_OUTLINE];
Assert(tp->width > 0);
Assert(tp->height > 0);
tp->window = JXCreateWindow(display, rootWindow,
tp->x, tp->y, tp->width, tp->height,
TRAY_BORDER_SIZE,
rootVisual.depth, InputOutput,
rootVisual.visual, attrMask, &attr);
if(settings.trayOpacity < UINT_MAX) {
/* Can't use atoms yet as it hasn't been initialized. */
atom = JXInternAtom(display, opacityAtom, False);
JXChangeProperty(display, tp->window, atom, XA_CARDINAL, 32,
PropModeReplace,
(unsigned char*)&settings.trayOpacity, 1);
}
SetDefaultCursor(tp->window);
/* Create and layout items on the tray. */
xoffset = 0;
yoffset = 0;
for(cp = tp->components; cp; cp = cp->next) {
if(cp->Create) {
if(tp->layout == LAYOUT_HORIZONTAL) {
height = tp->height;
width = cp->width;
if(width == 0) {
width = variableSize;
if(variableRemainder) {
width += 1;
variableRemainder -= 1;
}
}
} else {
width = tp->width;
height = cp->height;
if(height == 0) {
height = variableSize;
if(variableRemainder) {
height += 1;
variableRemainder -= 1;
}
}
}
cp->width = Max(1, width);
cp->height = Max(1, height);
(cp->Create)(cp);
}
cp->x = xoffset;
cp->y = yoffset;
cp->screenx = tp->x + xoffset;
cp->screeny = tp->y + yoffset;
if(cp->window != None) {
JXReparentWindow(display, cp->window, tp->window,
xoffset, yoffset);
}
if(tp->layout == LAYOUT_HORIZONTAL) {
xoffset += cp->width;
} else {
yoffset += cp->height;
}
}
/* Show the tray. */
JXMapWindow(display, tp->window);
trayCount += 1;
}
RequirePagerUpdate();
RequireTaskUpdate();
}
/** Move a client window. */
char MoveClient(ClientNode *np, int startx, int starty)
{
XEvent event;
int oldx, oldy;
int doMove;
int north, south, east, west;
int height;
MaxFlags maxFlags;
Assert(np);
if(!(np->state.border & BORDER_MOVE)) {
return 0;
}
if(np->state.status & STAT_FULLSCREEN) {
return 0;
}
GrabMouseForMove();
RegisterCallback(0, SignalMove, NULL);
np->controller = MoveController;
shouldStopMove = 0;
oldx = np->x;
oldy = np->y;
maxFlags = np->state.maxFlags;
if(!(GetMouseMask() & (Button1Mask | Button2Mask))) {
StopMove(np, 0, oldx, oldy, maxFlags);
return 0;
}
GetBorderSize(&np->state, &north, &south, &east, &west);
startx -= west;
starty -= north;
currentClient = np;
atTop = atBottom = atLeft = atRight = 0;
doMove = 0;
for(;;) {
WaitForEvent(&event);
if(shouldStopMove) {
np->controller = NULL;
SetDefaultCursor(np->parent);
UnregisterCallback(SignalMove, NULL);
return doMove;
}
switch(event.type) {
case ButtonRelease:
if(event.xbutton.button == Button1
|| event.xbutton.button == Button2) {
StopMove(np, doMove, oldx, oldy, maxFlags);
return doMove;
}
break;
case MotionNotify:
DiscardMotionEvents(&event, np->window);
np->x = event.xmotion.x_root - startx;
np->y = event.xmotion.y_root - starty;
/* Get the move time used for desktop switching. */
if(!(atLeft | atTop | atRight | atBottom)) {
if(event.xmotion.state & Mod1Mask) {
moveTime.seconds = 0;
moveTime.ms = 0;
} else {
GetCurrentTime(&moveTime);
}
}
/* Determine if we are at a border for desktop switching. */
atLeft = atTop = atRight = atBottom = 0;
if(event.xmotion.x_root == 0) {
atLeft = 1;
} else if(event.xmotion.x_root == rootWidth - 1) {
atRight = 1;
}
if(event.xmotion.y_root == 0) {
atTop = 1;
} else if(event.xmotion.y_root == rootHeight - 1) {
atBottom = 1;
}
if(event.xmotion.state & Mod1Mask) {
/* Switch desktops immediately if alt is pressed. */
if(atLeft | atRight | atTop | atBottom) {
TimeType now;
GetCurrentTime(&now);
UpdateDesktop(&now);
}
} else {
/* If alt is not pressed, snap to borders. */
DoSnap(np);
}
if(!doMove && (abs(np->x - oldx) > MOVE_DELTA
|| abs(np->y - oldy) > MOVE_DELTA)) {
if(np->state.maxFlags) {
MaximizeClient(np, MAX_NONE);
startx = np->width / 2;
starty = -north / 2;
MoveMouse(np->parent, startx, starty);
}
CreateMoveWindow(np);
doMove = 1;
}
if(doMove) {
if(settings.moveMode == MOVE_OUTLINE) {
ClearOutline();
height = north + south;
if(!(np->state.status & STAT_SHADED)) {
height += np->height;
}
DrawOutline(np->x - west, np->y - north,
np->width + west + east, height);
} else {
JXMoveWindow(display, np->parent, np->x - west,
np->y - north);
SendConfigureEvent(np);
}
UpdateMoveWindow(np);
RequirePagerUpdate();
}
break;
default:
break;
}
}
}
/** Startup trays. */
void StartupTray() {
XSetWindowAttributes attr;
Atom opacityAtom;
unsigned long attrMask;
TrayType *tp;
TrayComponentType *cp;
int variableSize;
int variableRemainder;
int width, height;
int xoffset, yoffset;
for(tp = trays; tp; tp = tp->next) {
LayoutTray(tp, &variableSize, &variableRemainder);
/* Create the tray window. */
/* The window is created larger for a border. */
attrMask = CWOverrideRedirect;
attr.override_redirect = True;
/* We can't use PointerMotionHintMask since the exact position
* of the mouse on the tray is important for popups. */
attrMask |= CWEventMask;
attr.event_mask
= ButtonPressMask
| ButtonReleaseMask
| SubstructureNotifyMask
| ExposureMask
| KeyPressMask
| KeyReleaseMask
| EnterWindowMask
| PointerMotionMask;
attrMask |= CWBackPixel;
attr.background_pixel = colors[COLOR_TRAY_BG];
tp->window = JXCreateWindow(display, rootWindow,
tp->x, tp->y, tp->width, tp->height,
0, rootDepth, InputOutput, rootVisual, attrMask, &attr);
if(trayOpacity < UINT_MAX) {
/* Can't use atoms yet as it hasn't been initialized. */
opacityAtom = JXInternAtom(display, "_NET_WM_WINDOW_OPACITY", False);
JXChangeProperty(display, tp->window, opacityAtom, XA_CARDINAL, 32,
PropModeReplace, (unsigned char*)&trayOpacity, 1);
JXSync(display, False);
}
SetDefaultCursor(tp->window);
/* Create and layout items on the tray. */
xoffset = tp->border;
yoffset = tp->border;
for(cp = tp->components; cp; cp = cp->next) {
if(cp->Create) {
if(tp->layout == LAYOUT_HORIZONTAL) {
height = tp->height - 2 * tp->border;
width = cp->width;
if(width == 0) {
width = variableSize;
if(variableRemainder) {
++width;
--variableRemainder;
}
}
} else {
width = tp->width - 2 * tp->border;
height = cp->height;
if(height == 0) {
height = variableSize;
if(variableRemainder) {
++height;
--variableRemainder;
}
}
}
cp->width = width;
cp->height = height;
(cp->Create)(cp);
}
cp->x = xoffset;
cp->y = yoffset;
cp->screenx = tp->x + xoffset;
cp->screeny = tp->y + yoffset;
if(cp->window != None) {
JXReparentWindow(display, cp->window, tp->window,
xoffset, yoffset);
}
if(tp->layout == LAYOUT_HORIZONTAL) {
xoffset += cp->width;
} else {
yoffset += cp->height;
}
}
/* Show the tray. */
JXMapWindow(display, tp->window);
++trayCount;
}
UpdatePager();
UpdateTaskBar();
}
