// reports the buttons as activatable regions to the EyeX host.
void UpdateActivatableRegions()
{
std::vector<EyeXHost::ActivatableRegion> regions;
regions.push_back(EyeXHost::ActivatableRegion(IDC_CHANGE_COLOR_BUTTON, GetScreenBounds(g_hChangeButton)));
regions.push_back(EyeXHost::ActivatableRegion(IDC_RESET_COLOR_BUTTON, GetScreenBounds(g_hResetButton)));
g_eyeXHost.SetActivatableRegions(regions);
}
void MythUIHelperPrivate::Init(void)
{
screensaver = ScreenSaverControl::get();
GetScreenBounds();
StoreGUIsettings();
screenSetup = true;
StorageGroup sgroup("Themes", gCoreContext->GetHostName());
m_userThemeDir = sgroup.GetFirstDir(true);
}
void ErrorPopUpScreen::Draw(float totalTime, float elapsedTime)
{
UNREFERENCED_PARAMETER(totalTime);
UNREFERENCED_PARAMETER(elapsedTime);
auto screenManager = Manager();
auto spriteBatch = screenManager->GetSpriteBatch();
auto spriteFont = screenManager->GetSpriteFont();
auto blendStates = screenManager->GetCommonStates();
auto viewportBounds = screenManager->GetScreenBounds();
float viewportWidth = float(viewportBounds.right);
float viewportHeight = float(viewportBounds.bottom);
auto scaleMatrix = DX::GetScaleMatrixForWindow(screenManager->GetWindowBounds());
// calculate position and size of error message
XMFLOAT2 errorMsgPosition = XMFLOAT2(0, viewportHeight / 2.0f);
XMVECTORF32 errorMsgColor = Colors::Yellow;
XMFLOAT2 origin = XMFLOAT2(0, spriteFont->GetLineSpacing() / 2.0f);
XMVECTOR size = spriteFont->MeasureString(m_errorMessage.c_str());
errorMsgPosition.x = viewportWidth / 2.0f - XMVectorGetX(size) / 2.0f;
// create a rectangle representing the screen dimensions of the error message background rectangle
long rectangleWidth = long(std::min(std::max(XMVectorGetX(size) + 100.0f, 600.0f), viewportWidth));
long rectangleHeight = long(spriteFont->GetLineSpacing() * 6.0f);
long rectangleLeft = long(viewportWidth / 2.0f) - (rectangleWidth / 2);
long rectangleTop = long(errorMsgPosition.y + spriteFont->GetLineSpacing()) - (rectangleHeight / 2);
RECT backgroundRectangle = { rectangleLeft, rectangleTop, rectangleLeft + rectangleWidth, rectangleTop + rectangleHeight };
spriteBatch->Begin(SpriteSortMode_Deferred, blendStates->NonPremultiplied(), nullptr, nullptr, nullptr, nullptr, scaleMatrix);
// draw a background color for the rectangle
spriteBatch->Draw(m_backgroundTexture->GetResourceViewTemporary(), backgroundRectangle, BackgroundColor);
// draw error message in the middle of the screen
spriteFont->DrawString(spriteBatch.get(), m_errorMessage.c_str(), errorMsgPosition, errorMsgColor, 0, origin);
// draw continuation prompt
winrt::hstring continuePrompt = L"Press (A) to Continue";
if (!InputState::IsAnyGamepadConnected())
{
continuePrompt = L"Press Enter to Continue";
}
errorMsgPosition.y += spriteFont->GetLineSpacing();
size = spriteFont->MeasureString(continuePrompt.c_str());
errorMsgPosition.x = viewportWidth / 2.0f - XMVectorGetX(size) / 2.0f;
spriteFont->DrawString(spriteBatch.get(), continuePrompt.c_str(), errorMsgPosition, Colors::Yellow, 0, origin);
spriteBatch->End();
}
/** Place a client on the screen. */
void PlaceClient(ClientNode *np, char alreadyMapped)
{
BoundingBox box;
const ScreenType *sp;
Assert(np);
if(alreadyMapped || (!(np->state.status & STAT_PIGNORE)
&& (np->sizeFlags & (PPosition | USPosition)))) {
GravitateClient(np, 0);
if(!alreadyMapped) {
ConstrainSize(np);
ConstrainPosition(np);
}
} else {
sp = GetMouseScreen();
GetScreenBounds(sp, &box);
SubtractTrayBounds(GetTrays(), &box, np->state.layer);
SubtractStrutBounds(&box, np);
/* If tiled is specified, first attempt to use tiled placement. */
if(np->state.status & STAT_TILED) {
if(TileClient(&box, np)) {
return;
}
}
/* Either tiled placement failed or was not specified. */
if(np->state.status & STAT_CENTERED) {
CenterClient(&box, np);
} else {
CascadeClient(&box, np);
}
}
}
/** Set a client's full screen state. */
void SetClientFullScreen(ClientNode *np, char fullScreen)
{
XEvent event;
int north, south, east, west;
BoundingBox box;
const ScreenType *sp;
Assert(np);
/* Make sure there's something to do. */
if(!fullScreen == !(np->state.status & STAT_FULLSCREEN)) {
return;
}
if(!(np->state.border & BORDER_FULLSCREEN)) {
return;
}
if(np->state.status & STAT_SHADED) {
UnshadeClient(np);
}
if(fullScreen) {
np->state.status |= STAT_FULLSCREEN;
if(!(np->state.maxFlags)) {
np->oldx = np->x;
np->oldy = np->y;
np->oldWidth = np->width;
np->oldHeight = np->height;
}
sp = GetCurrentScreen(np->x, np->y);
GetScreenBounds(sp, &box);
GetBorderSize(&np->state, &north, &south, &east, &west);
box.x += west;
box.y += north;
box.width -= east + west;
box.height -= north + south;
np->x = box.x;
np->y = box.y;
np->width = box.width;
np->height = box.height;
ResetBorder(np);
} else {
np->state.status &= ~STAT_FULLSCREEN;
np->x = np->oldx;
np->y = np->oldy;
np->width = np->oldWidth;
np->height = np->oldHeight;
ConstrainSize(np);
ConstrainPosition(np);
if(np->state.maxFlags != MAX_NONE) {
PlaceMaximizedClient(np, np->state.maxFlags);
}
ResetBorder(np);
event.type = MapRequest;
event.xmaprequest.send_event = True;
event.xmaprequest.display = display;
event.xmaprequest.parent = np->parent;
event.xmaprequest.window = np->window;
JXSendEvent(display, rootWindow, False,
SubstructureRedirectMask, &event);
}
WriteState(np);
SendConfigureEvent(np);
RequireRestack();
}
/** Place a maximized client on the screen. */
void PlaceMaximizedClient(ClientNode *np, MaxFlags flags)
{
BoundingBox box;
const ScreenType *sp;
int north, south, east, west;
np->oldx = np->x;
np->oldy = np->y;
np->oldWidth = np->width;
np->oldHeight = np->height;
GetBorderSize(&np->state, &north, &south, &east, &west);
sp = GetCurrentScreen(np->x + (east + west + np->width) / 2,
np->y + (north + south + np->height) / 2);
GetScreenBounds(sp, &box);
if(!(flags & (MAX_HORIZ | MAX_LEFT | MAX_RIGHT))) {
box.x = np->x - west;
box.width = np->width + east + west;
}
if(!(flags & (MAX_VERT | MAX_TOP | MAX_BOTTOM))) {
box.y = np->y - north;
box.height = np->height + north + south;
}
SubtractTrayBounds(GetTrays(), &box, np->state.layer);
SubtractStrutBounds(&box, np);
if(box.width > np->maxWidth) {
box.width = np->maxWidth;
}
if(box.height > np->maxHeight) {
box.height = np->maxHeight;
}
if(np->sizeFlags & PAspect) {
if(box.width * np->aspect.miny < box.height * np->aspect.minx) {
box.height = (box.width * np->aspect.miny) / np->aspect.minx;
}
if(box.width * np->aspect.maxy > box.height * np->aspect.maxx) {
box.width = (box.height * np->aspect.maxx) / np->aspect.maxy;
}
}
/* Remove window outlines. */
if(flags & (MAX_VERT | MAX_TOP)) {
north = Max(0, north - 1);
}
if(flags & (MAX_VERT | MAX_BOTTOM)) {
south = Max(0, south - 1);
}
if(flags & (MAX_HORIZ | MAX_LEFT)) {
west = Max(0, west - 1);
}
if(flags & (MAX_HORIZ | MAX_RIGHT)) {
east = Max(0, east - 1);
}
/* If maximizing horizontally, update width. */
if(flags & MAX_HORIZ) {
np->x = box.x;
np->width = box.width;
if(!(np->state.status & STAT_IIGNORE)) {
np->width -= ((box.width - np->baseWidth) % np->xinc);
}
} else if(flags & MAX_LEFT) {
np->x = box.x;
np->width = box.width / 2 - west;
if(!(np->state.status & STAT_IIGNORE)) {
np->width -= ((box.width - np->baseWidth) % np->xinc);
}
} else if(flags & MAX_RIGHT) {
np->x = box.x + box.width / 2 + west;
np->width = box.width / 2 - east;
if(!(np->state.status & STAT_IIGNORE)) {
np->width -= ((box.width - np->baseWidth) % np->xinc);
}
}
/* If maximizing vertically, update height. */
if(flags & MAX_VERT) {
np->y = box.y + north;
np->height = box.height - north;
if(!(np->state.status & STAT_IIGNORE)) {
np->height -= ((box.height - np->baseHeight) % np->yinc);
}
} else if(flags & MAX_TOP) {
np->y = box.y + north;
np->height = box.height / 2 - north - south;
if(!(np->state.status & STAT_IIGNORE)) {
np->height -= ((box.height - np->baseHeight) % np->yinc);
}
} else if(flags & MAX_BOTTOM) {
np->y = box.y + box.height / 2 + north;
np->height = box.height / 2 - north - south;
if(!(np->state.status & STAT_IIGNORE)) {
np->height -= ((box.height - np->baseHeight) % np->yinc);
}
}
np->state.maxFlags = flags;
}
/** Constrain the size of the client. */
char ConstrainSize(ClientNode *np)
{
BoundingBox box;
const ScreenType *sp;
int north, south, east, west;
const int oldWidth = np->width;
const int oldHeight = np->height;
/* First we make sure the window isn't larger than the program allows.
* We do this here to avoid moving the window below.
*/
np->width = Min(np->width, np->maxWidth);
np->height = Min(np->height, np->maxHeight);
/* Constrain the width if necessary. */
sp = GetCurrentScreen(np->x, np->y);
GetScreenBounds(sp, &box);
SubtractTrayBounds(GetTrays(), &box, np->state.layer);
SubtractStrutBounds(&box, np);
GetBorderSize(&np->state, &north, &south, &east, &west);
if(np->width + east + west > sp->width) {
box.x += west;
box.width -= east + west;
if(box.width > np->maxWidth) {
box.width = np->maxWidth;
}
if(box.width > np->width) {
box.width = np->width;
}
np->x = box.x;
np->width = box.width - (box.width % np->xinc);
}
/* Constrain the height if necessary. */
if(np->height + north + south > sp->height) {
box.y += north;
box.height -= north + south;
if(box.height > np->maxHeight) {
box.height = np->maxHeight;
}
if(box.height > np->height) {
box.height = np->height;
}
np->y = box.y;
np->height = box.height - (box.height % np->yinc);
}
/* If the program has a minimum constraint, we apply that here.
* Note that this could cause the window to overlap something. */
np->width = Max(np->width, np->minWidth);
np->height = Max(np->height, np->minHeight);
/* Fix the aspect ratio. */
if(np->sizeFlags & PAspect) {
if(np->width * np->aspect.miny < np->height * np->aspect.minx) {
np->height = (np->width * np->aspect.miny) / np->aspect.minx;
}
if(np->width * np->aspect.maxy > np->height * np->aspect.maxx) {
np->width = (np->height * np->aspect.maxx) / np->aspect.maxy;
}
}
if(np->width != oldWidth || np->height != oldHeight) {
return 1;
} else {
return 0;
}
}
