WallyHackenslacker/Aerofoil
1
0
Fork 0
mirror of https://github.com/elasota/Aerofoil.git synced 2025-12-14 12:09:36 +00:00
Code Issues Projects Releases Wiki Activity

Window API refactor

Browse Source
This commit is contained in:
elasota
2020-05-20 17:20:50 -04:00
parent 49c438b088
commit f53dc21475
26 changed files with 137 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
PortabilityLayer/BitmapImage.cpp
View File

@@ -8,5 +8,5 @@ Rect BitmapImage::GetRect() const
const uint32_t width = infoHeader->m_width;
const uint32_t height = infoHeader->m_height;
return Rect::Create(0, 0, static_cast<int16_t>(height), static_cast<int16_t>(width));
return Rect::Create(0, 0, static_cast<int16_t>(height), static_cast<int16_t>(width));
}

20
PortabilityLayer/DialogManager.cpp
View File

@@ -511,11 +511,7 @@ namespace PortabilityLayer
Point DialogImpl::MouseToDialog(const GpMouseInputEvent &evt)
{
const Window *window = m_window;
const int32_t x = evt.m_x - window->m_wmX;
const int32_t y = evt.m_y - window->m_wmY;
return Point::Create(x, y);
return Point::Create(evt.m_x, evt.m_y) - m_window->GetTopLeftCoord();
}
void DialogImpl::MakeStringSubstitutions(uint8_t *outStr, const uint8_t *inStr, const DialogTextSubstitutions *substitutions)
@@ -843,7 +839,9 @@ namespace PortabilityLayer
const uint16_t dialogWidth = rect.Width();
const uint16_t dialogHeight = rect.Height();
window->m_wmX = (static_cast<int32_t>(displayWidth) - static_cast<int32_t>(dialogWidth)) / 2;
Vec2i newPosition;
newPosition.m_x = (static_cast<int32_t>(displayWidth) - static_cast<int32_t>(dialogWidth)) / 2;
// We center dialogs vertically in one of 3 ways in this priority:
// - Centered at 1/3 until the top edge is at the 1/4 mark
@@ -853,13 +851,15 @@ namespace PortabilityLayer
//if (displayHeight / 3 - dialogHeight / 2 >= displayHeight / 4)
if (static_cast<int32_t>(displayHeight * 4) - static_cast<int32_t>(dialogHeight * 6) >= static_cast<int32_t>(displayHeight * 3))
{
//window->m_wmY = displayHeight / 3 - dialogHeight / 2;
window->m_wmY = (static_cast<int32_t>(displayHeight * 2) - static_cast<int32_t>(dialogHeight * 3)) / 6;
//newPosition.m_y = displayHeight / 3 - dialogHeight / 2;
newPosition.m_y = (static_cast<int32_t>(displayHeight * 2) - static_cast<int32_t>(dialogHeight * 3)) / 6;
}
else if (dialogHeight * 2U <= displayHeight)
window->m_wmY = displayHeight / 4;
newPosition.m_y = displayHeight / 4;
else
window->m_wmY = (static_cast<int32_t>(displayHeight) - static_cast<int32_t>(dialogHeight)) / 2;
newPosition.m_y = (static_cast<int32_t>(displayHeight) - static_cast<int32_t>(dialogHeight)) / 2;
window->SetPosition(newPosition);
}
DialogManagerImpl *DialogManagerImpl::GetInstance()

2
PortabilityLayer/PLButtonWidget.cpp
View File

@@ -649,7 +649,7 @@ namespace PortabilityLayer
if (m_haveHighlightOverride != enabled)
{
m_haveHighlightOverride = enabled;
DrawControl(&m_window->m_surface);
DrawControl(m_window->GetDrawSurface());
}
}
}

28
PortabilityLayer/PLCore.cpp
View File

@@ -128,7 +128,7 @@ PortabilityLayer::Vec2i TrackResize(WindowPtr window, Point start, uint16_t minW
{
PortabilityLayer::WindowManager *wm = PortabilityLayer::WindowManager::GetInstance();
const Rect baseRect = window->m_surface.m_port.GetRect();
const Rect baseRect = window->GetSurfaceRect();
const PortabilityLayer::Vec2i baseSize = PortabilityLayer::Vec2i(baseRect.Width(), baseRect.Height());
const PortabilityLayer::Vec2i basePoint = PortabilityLayer::Vec2i(start.h, start.v);
@@ -498,8 +498,9 @@ void DisposeDirectoryFiles(DirectoryFileListEntry *firstDFL)
void GetMouse(Window *window, Point *point)
{
const PortabilityLayer::Vec2i mousePos = PortabilityLayer::InputManager::GetInstance()->GetMousePosition();
point->h = mousePos.m_x - window->m_wmX;
point->v = mousePos.m_y - window->m_wmY;
const PortabilityLayer::Vec2i relativePos = mousePos - window->GetPosition();
point->h = relativePos.m_x;
point->v = relativePos.m_y;
}
Boolean Button()
@@ -691,9 +692,26 @@ Point Window::MouseToLocal(const GpMouseInputEvent &evt) const
return Point::Create(evt.m_x - m_wmX, evt.m_y - m_wmY);
}
Point Window::TopLeftCoord() const
Point Window::GetTopLeftCoord() const
{
return Point::Create(m_wmX, m_wmY);
const PortabilityLayer::Vec2i position = GetPosition();
return Point::Create(position.m_x, position.m_y);
}
Rect Window::GetSurfaceRect() const
{
return m_surface.m_port.GetRect();
}
void Window::SetPosition(const PortabilityLayer::Vec2i &pos)
{
m_wmX = pos.m_x;
m_wmY = pos.m_y;
}
PortabilityLayer::Vec2i Window::GetPosition() const
{
return PortabilityLayer::Vec2i(m_wmX, m_wmY);
}
bool Window::AddWidget(PortabilityLayer::Widget *widget)

23
PortabilityLayer/PLCore.h
View File

@@ -91,13 +91,17 @@ struct Window
{
Window();
DrawSurface *GetDrawSurface() const;
void SetPosition(const PortabilityLayer::Vec2i &pos);
PortabilityLayer::Vec2i GetPosition() const;
// Convenience method to convert a mouse event to local point
Point MouseToLocal(const GpMouseInputEvent &evt) const;
// Convenience method that returns a 16-bit precision X/Y
Point TopLeftCoord() const;
Point GetTopLeftCoord() const;
// Returns the bounds rect of the draw surface (which is always 0,0 based
Rect GetSurfaceRect() const;
bool AddWidget(PortabilityLayer::Widget *widget);
ArrayView<PortabilityLayer::Widget*> GetWidgets() const;
@@ -112,15 +116,9 @@ struct Window
void OnTick();
DrawSurface *GetDrawSurface() const;
DrawSurface *GetChromeSurface(WindowChromeSide_t aChromeSide) const;
DrawSurface m_surface; // Must be the first item until the immediate mode draw API is completely removed
// The port is always at 0,0
// These are the WM coordinates
int32_t m_wmX;
int32_t m_wmY;
protected:
~Window();
@@ -130,6 +128,13 @@ protected:
size_t m_numWidgets;
size_t m_numTickReceivingWidgets;
DrawSurface m_surface;
// The surface is always at 0,0
// These are the WM coordinates
int32_t m_wmX;
int32_t m_wmY;
PortabilityLayer::Widget *m_widgetWithFocus;
};

6
PortabilityLayer/PLPopupMenuWidget.cpp
View File

@@ -41,7 +41,7 @@ namespace PortabilityLayer
{
const GpMouseInputEvent &mouseEvent = evt.m_vosEvent.m_event.m_mouseInputEvent;
const Vec2i globalPoint = Vec2i(mouseEvent.m_x, mouseEvent.m_y);
const Vec2i localPoint = globalPoint - Vec2i(m_window->m_wmX, m_window->m_wmY);
const Vec2i localPoint = globalPoint - m_window->GetPosition();
if (this->m_rect.Contains(Point::Create(localPoint.m_x, localPoint.m_y)))
{
@@ -60,8 +60,8 @@ namespace PortabilityLayer
{
MenuManager *mm = PortabilityLayer::MenuManager::GetInstance();
const Vec2i popupMenuPos = Vec2i(m_window->m_wmX, m_window->m_wmY) + Vec2i(m_rect.left, m_rect.top);
const Vec2i globalPos = Vec2i(pos.h, pos.v) + Vec2i(m_window->m_wmX, m_window->m_wmY);
const Vec2i popupMenuPos = m_window->GetPosition() + Vec2i(m_rect.left, m_rect.top);
const Vec2i globalPos = Vec2i(pos.h, pos.v) + m_window->GetPosition();
uint16_t item = 0;
mm->PopupMenuSelect(m_menu, popupMenuPos, globalPos, m_state - 1, &item);

15
PortabilityLayer/PLQDraw.cpp
View File

@@ -51,7 +51,7 @@ void SetPort(GrafPtr graf)
void EndUpdate(WindowPtr graf)
{
graf->m_surface.m_port.SetDirty(PortabilityLayer::QDPortDirtyFlag_Contents);
graf->GetDrawSurface()->m_port.SetDirty(PortabilityLayer::QDPortDirtyFlag_Contents);
}
void SetRect(Rect *rect, short left, short top, short right, short bottom)
@@ -65,7 +65,7 @@ void SetRect(Rect *rect, short left, short top, short right, short bottom)
void SetPortWindowPort(WindowPtr window)
{
PortabilityLayer::WindowManager *wm = PortabilityLayer::WindowManager::GetInstance();
PortabilityLayer::QDManager::GetInstance()->SetPort(&window->m_surface.m_port);
PortabilityLayer::QDManager::GetInstance()->SetPort(&window->GetDrawSurface()->m_port);
}
void SetPortDialogPort(Dialog *dialog)
@@ -1708,17 +1708,6 @@ PixMap *GetPortBitMapForCopyBits(DrawSurface *grafPtr)
return *grafPtr->m_port.GetPixMap();
}
DrawSurface *GetWindowPort(WindowPtr window)
{
return &window->m_surface;
}
void SubPt(Point srcPoint, Point *destPoint)
{
PL_NotYetImplemented();
}
Boolean SectRect(const Rect *rectA, const Rect *rectB, Rect *outIntersection)
{
*outIntersection = rectA->Intersect(*rectB);

4
PortabilityLayer/PLQDraw.h
View File

@@ -99,10 +99,6 @@ void ImageInvert(const PixMap *invertMask, PixMap *targetBitmap, const Rect &src
bool PointInScanlineMask(Point point, PortabilityLayer::ScanlineMask *scanlineMask);
PixMap *GetPortBitMapForCopyBits(DrawSurface *grafPtr);
DrawSurface *GetWindowPort(WindowPtr window);
// Subtracts srcPoint from destPoint (reverse of DeltaPoint)
void SubPt(Point srcPoint, Point *destPoint);
Boolean SectRect(const Rect *rectA, const Rect *rectB, Rect *outIntersection);

2
PortabilityLayer/QDGraf.h
View File

@@ -24,7 +24,7 @@ struct IGpDisplayDriver;
struct IGpDisplayDriverSurface;
class PLPasStr;
struct DrawSurface final
struct DrawSurface
{
DrawSurface()
: m_port(PortabilityLayer::QDPortType_DrawSurface)

60
PortabilityLayer/WindowManager.cpp
View File

@@ -1059,10 +1059,11 @@ namespace PortabilityLayer
WindowImpl *window = m_windowStackTop;
while (window)
{
const Rect windowRect = window->m_surface.m_port.GetRect();
const Rect windowRect = window->GetSurfaceRect();
const Vec2i windowPos = window->GetPosition();
const int32_t localX = point.h - window->m_wmX;
const int32_t localY = point.v - window->m_wmY;
const int32_t localX = point.h - windowPos.m_x;
const int32_t localY = point.v - windowPos.m_y;
RegionID_t chromeInteractionZone = RegionIDs::kContent;
if (window->GetChromeInteractionZone(Vec2i(localX, localY), chromeInteractionZone))
@@ -1101,7 +1102,7 @@ namespace PortabilityLayer
DetachWindow(window);
if (PortabilityLayer::QDManager::GetInstance()->GetPort() == &windowImpl->m_surface.m_port)
if (PortabilityLayer::QDManager::GetInstance()->GetPort() == &windowImpl->GetDrawSurface()->m_port)
PortabilityLayer::QDManager::GetInstance()->SetPort(nullptr);
windowImpl->~WindowImpl();
@@ -1133,8 +1134,7 @@ namespace PortabilityLayer
if (y >= constraintRect.bottom)
y = constraintRect.bottom - 1;
window->m_wmX += x - baseX;
window->m_wmY += y - baseY;
window->SetPosition(window->GetPosition() + Vec2i(x - baseX, y - baseY));
baseX = x;
baseY = y;
@@ -1150,7 +1150,7 @@ namespace PortabilityLayer
{
bool isInBounds = false;
const Vec2i windowCoord = Vec2i(window->m_wmX, window->m_wmY);
const Vec2i windowCoord = window->GetPosition();
Rect2i closeBoxRect;
if (!static_cast<WindowImpl*>(window)->GetChromeRegionRect(RegionIDs::kClose, closeBoxRect))
@@ -1216,9 +1216,10 @@ namespace PortabilityLayer
uint16_t padding[WindowChromeSides::kCount];
windowImpl->GetChromePadding(padding);
const Rect portRect = windowImpl->m_surface.m_port.GetRect();
const Rect portRect = windowImpl->GetSurfaceRect();
const Vec2i windowPos = windowImpl->GetPosition();
return Rect2i(window->m_wmY - padding[WindowChromeSides::kTop], window->m_wmX - padding[WindowChromeSides::kLeft], window->m_wmY + portRect.Height() + padding[WindowChromeSides::kBottom], window->m_wmX + portRect.Width() + padding[WindowChromeSides::kRight]);
return Rect2i(windowPos.m_y - padding[WindowChromeSides::kTop], windowPos.m_x - padding[WindowChromeSides::kLeft], windowPos.m_y + portRect.Height() + padding[WindowChromeSides::kBottom], windowPos.m_x + portRect.Width() + padding[WindowChromeSides::kRight]);
}
bool WindowManagerImpl::GetWindowChromeInteractionZone(Window *window, const Vec2i &point, RegionID_t &outRegion) const
@@ -1242,7 +1243,7 @@ namespace PortabilityLayer
const Rect windowRect = window->GetDrawSurface()->m_port.GetRect();
Vec2i topLeft = Vec2i(m_flickerWindow->m_wmX, m_flickerWindow->m_wmY);
Vec2i topLeft = m_flickerWindow->GetPosition();
Vec2i dimensions = Vec2i(windowRect.Width(), windowRect.Height());
m_flickerAxis = Vec2i(1, 1);
@@ -1269,9 +1270,9 @@ namespace PortabilityLayer
int32_t chromeLead = 64;
int32_t flickerZoneSize = 128;
const Rect windowRect = window->GetDrawSurface()->m_port.GetRect();
const Rect windowRect = window->GetSurfaceRect();
Vec2i topLeft = Vec2i(m_flickerWindow->m_wmX, m_flickerWindow->m_wmY);
Vec2i topLeft = m_flickerWindow->GetPosition();
Vec2i dimensions = Vec2i(windowRect.Width(), windowRect.Height());
m_flickerAxis = Vec2i(-1, -1);
@@ -1323,7 +1324,7 @@ namespace PortabilityLayer
return;
}
const PortabilityLayer::Vec2i topLeft = PortabilityLayer::Vec2i(window->m_wmX, window->m_wmY);
const PortabilityLayer::Vec2i topLeft = window->GetPosition();
m_resizeInProgressRect = PortabilityLayer::Rect2i(topLeft, topLeft + size);
}
@@ -1379,12 +1380,13 @@ namespace PortabilityLayer
{
uint32_t prevClearanceX = prevWidth - paddedWidth;
uint32_t newClearanceX = newWidth - paddedWidth;
newX = static_cast<int64_t>(window->m_wmX) * static_cast<int64_t>(newClearanceX) / static_cast<int64_t>(prevClearanceX);
newX = static_cast<int64_t>(window->GetPosition().m_x) * static_cast<int64_t>(newClearanceX) / static_cast<int64_t>(prevClearanceX);
}
int64_t newY = 0;
if (window->m_wmY < static_cast<int32_t>(menuBarHeight))
newY = window->m_wmY;
int32_t currentY = window->GetPosition().m_y;
if (currentY < static_cast<int32_t>(menuBarHeight))
newY = currentY;
else
{
if (newHeight <= (paddedHeight + menuBarHeight) || prevHeight <= paddedHeight + menuBarHeight)
@@ -1393,15 +1395,14 @@ namespace PortabilityLayer
{
uint32_t prevClearanceY = prevHeight - paddedHeight - menuBarHeight;
uint32_t newClearanceY = newHeight - paddedHeight - menuBarHeight;
newY = (static_cast<int64_t>(window->m_wmY) - static_cast<int64_t>(menuBarHeight) - chromePadding[WindowChromeSides::kTop]) * static_cast<int64_t>(newClearanceY) / static_cast<int64_t>(prevClearanceY) + menuBarHeight + chromePadding[WindowChromeSides::kTop];
newY = (static_cast<int64_t>(currentY) - static_cast<int64_t>(menuBarHeight) - chromePadding[WindowChromeSides::kTop]) * static_cast<int64_t>(newClearanceY) / static_cast<int64_t>(prevClearanceY) + menuBarHeight + chromePadding[WindowChromeSides::kTop];
}
}
newX = std::max<int64_t>(0, std::min<int64_t>(newX, newWidth - 1));
newY = std::max<int64_t>(0, std::min<int64_t>(newY, newHeight - 1));
window->m_wmX = static_cast<int32_t>(newX);
window->m_wmY = static_cast<int32_t>(newY);
window->SetPosition(Vec2i(newX, newY));
}
}
@@ -1412,8 +1413,7 @@ namespace PortabilityLayer
void WindowManagerImpl::MoveWindow(Window *window, int x, int y)
{
window->m_wmX = x;
window->m_wmY = y;
window->SetPosition(Vec2i(x, y));
}
void WindowManagerImpl::DetachWindow(Window *window)
@@ -1477,7 +1477,7 @@ namespace PortabilityLayer
bool hasFlicker = (m_flickerWindow == window);
DrawSurface &graf = window->m_surface;
DrawSurface &graf = *window->GetDrawSurface();
graf.PushToDDSurface(displayDriver);
@@ -1485,10 +1485,12 @@ namespace PortabilityLayer
const uint16_t width = pixMap->m_rect.Width();
const uint16_t height = pixMap->m_rect.Height();
if (hasFlicker)
ComputeFlickerEffects(Vec2i(window->m_wmX, window->m_wmY), 0, effects);
const Vec2i windowPos = window->GetPosition();
displayDriver->DrawSurface(graf.m_ddSurface, window->m_wmX, window->m_wmY, width, height, &effects);
if (hasFlicker)
ComputeFlickerEffects(windowPos, 0, effects);
displayDriver->DrawSurface(graf.m_ddSurface, windowPos.m_x, windowPos.m_y, width, height, &effects);
if (!window->IsBorderless())
{
@@ -1496,10 +1498,10 @@ namespace PortabilityLayer
window->GetChromePadding(chromePadding);
Vec2i chromeOrigins[WindowChromeSides::kCount];
chromeOrigins[WindowChromeSides::kTop] = Vec2i(window->m_wmX - chromePadding[WindowChromeSides::kLeft], window->m_wmY - chromePadding[WindowChromeSides::kTop]);
chromeOrigins[WindowChromeSides::kLeft] = Vec2i(window->m_wmX - chromePadding[WindowChromeSides::kLeft], window->m_wmY);
chromeOrigins[WindowChromeSides::kRight] = Vec2i(window->m_wmX + width, window->m_wmY);
chromeOrigins[WindowChromeSides::kBottom] = Vec2i(window->m_wmX - chromePadding[WindowChromeSides::kLeft], window->m_wmY + height);
chromeOrigins[WindowChromeSides::kTop] = Vec2i(windowPos.m_x - chromePadding[WindowChromeSides::kLeft], windowPos.m_y - chromePadding[WindowChromeSides::kTop]);
chromeOrigins[WindowChromeSides::kLeft] = Vec2i(windowPos.m_x - chromePadding[WindowChromeSides::kLeft], windowPos.m_y);
chromeOrigins[WindowChromeSides::kRight] = Vec2i(windowPos.m_x + width, windowPos.m_y);
chromeOrigins[WindowChromeSides::kBottom] = Vec2i(windowPos.m_x - chromePadding[WindowChromeSides::kLeft], windowPos.m_y + height);
Vec2i chromeDimensions[WindowChromeSides::kCount];
chromeDimensions[WindowChromeSides::kTop] = Vec2i(chromePadding[WindowChromeSides::kLeft] + chromePadding[WindowChromeSides::kRight] + width, chromePadding[WindowChromeSides::kTop]);