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

Event queue refactor

Browse Source
This commit is contained in:
elasota
2019-12-31 03:55:17 -05:00
parent 84e4f9fb0b
commit 52338a3983
25 changed files with 244 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
PortabilityLayer/InputManager.cpp
View File

@@ -12,7 +12,7 @@ namespace PortabilityLayer
public:
InputManagerImpl();
void GetKeys(KeyMap &keyMap) const override;
void GetKeys(KeyDownStates &keyMap) const override;
void ApplyKeyboardEvent(const GpKeyboardInputEvent &vosEvent) override;
void ApplyGamepadEvent(const GpGamepadInputEvent &vosEvent) override;
int16_t GetGamepadAxis(unsigned int playerNum, GpGamepadAxis_t gamepadAxis) override;
@@ -23,13 +23,13 @@ namespace PortabilityLayer
void ApplyEventAsKey(const GpKeyboardInputEvent &vosEvent, bool bit);
void ApplyAnalogAxisEvent(const GpGamepadAnalogAxisEvent &axisEvent);
KeyMap m_keyMap;
KeyDownStates m_keyMap;
int16_t m_axisStates[PL_INPUT_MAX_PLAYERS][GpGamepadAxes::kCount];
static InputManagerImpl ms_instance;
};
void InputManagerImpl::GetKeys(KeyMap &keyMap) const
void InputManagerImpl::GetKeys(KeyDownStates &keyMap) const
{
keyMap = m_keyMap;
}

4
PortabilityLayer/InputManager.h
View File

@@ -4,14 +4,14 @@
struct GpKeyboardInputEvent;
struct GpGamepadInputEvent;
struct KeyMap;
struct KeyDownStates;
namespace PortabilityLayer
{
class InputManager
{
public:
virtual void GetKeys(KeyMap &keys16) const = 0;
virtual void GetKeys(KeyDownStates &keys16) const = 0;
virtual void ApplyKeyboardEvent(const GpKeyboardInputEvent &vosEvent) = 0;
virtual void ApplyGamepadEvent(const GpGamepadInputEvent &vosEvent) = 0;
virtual int16_t GetGamepadAxis(unsigned int playerNum, GpGamepadAxis_t gamepadAxis) = 0;

30
PortabilityLayer/MenuManager.cpp
View File

@@ -12,6 +12,7 @@
#include "PLCore.h"
#include "PLPasStr.h"
#include "PLResources.h"
#include "PLTimeTaggedVOSEvent.h"
#include "PLQDOffscreen.h"
#include "RenderedFont.h"
#include "QDGraf.h"
@@ -463,23 +464,28 @@ namespace PortabilityLayer
return;
}
EventRecord evt;
TimeTaggedVOSEvent evt;
bool canDismiss = false;
while (!canDismiss)
{
if (WaitNextEvent(everyEvent, &evt, 1, nullptr))
if (WaitForEvent(&evt, 1))
{
const EventCode eventCode = static_cast<EventCode>(evt.what);
switch (eventCode)
if (evt.m_vosEvent.m_eventType == GpVOSEventTypes::kMouseInput)
{
case mouseMove:
case mouseDown: // It's possible to get a mouse down event again if the mouse leaves the window and is downed again inside
ProcessMouseMoveTo(PortabilityLayer::Vec2i(evt.where.h, evt.where.v));
break;
case mouseUp:
canDismiss = true;
break;
switch (evt.m_vosEvent.m_event.m_mouseInputEvent.m_eventType)
{
case GpMouseEventTypes::kMove:
ProcessMouseMoveTo(PortabilityLayer::Vec2i(evt.m_vosEvent.m_event.m_mouseInputEvent.m_x, evt.m_vosEvent.m_event.m_mouseInputEvent.m_y));
break;
case GpMouseEventTypes::kDown:
if (evt.m_vosEvent.m_event.m_mouseInputEvent.m_button == GpMouseButtons::kLeft)
ProcessMouseMoveTo(PortabilityLayer::Vec2i(evt.m_vosEvent.m_event.m_mouseInputEvent.m_x, evt.m_vosEvent.m_event.m_mouseInputEvent.m_y));
break;
case GpMouseEventTypes::kUp:
if (evt.m_vosEvent.m_event.m_mouseInputEvent.m_button == GpMouseButtons::kLeft)
canDismiss = true;
break;
}
}
}
}

145
PortabilityLayer/PLCore.cpp
View File

@@ -33,6 +33,7 @@
#include "PLBigEndian.h"
#include "PLEventQueue.h"
#include "PLKeyEncoding.h"
#include "PLTimeTaggedVOSEvent.h"
#include "QDManager.h"
#include "Vec2i.h"
#include "WindowDef.h"
@@ -64,37 +65,25 @@ static bool ConvertFilenameToSafePStr(const char *str, uint8_t *pstr)
return true;
}
static void TranslateMouseInputEvent(const GpMouseInputEvent &vosEvent, PortabilityLayer::EventQueue *queue)
static void TranslateMouseInputEvent(const GpVOSEvent &vosEventBase, uint32_t timestamp, PortabilityLayer::EventQueue *queue)
{
const GpMouseInputEvent &vosEvent = vosEventBase.m_event.m_mouseInputEvent;
bool requeue = false;
if (vosEvent.m_button == GpMouseButtons::kLeft)
{
if (vosEvent.m_eventType == GpMouseEventTypes::kDown)
{
if (EventRecord *evt = queue->Enqueue())
{
evt->what = mouseDown;
evt->where.h = std::min<int32_t>(INT16_MAX, std::max<int32_t>(INT16_MIN, vosEvent.m_x));
evt->where.v = std::min<int32_t>(INT16_MAX, std::max<int32_t>(INT16_MIN, vosEvent.m_y));
}
}
requeue = true;
else if (vosEvent.m_eventType == GpMouseEventTypes::kUp)
{
if (EventRecord *evt = queue->Enqueue())
{
evt->what = mouseUp;
evt->where.h = std::min<int32_t>(INT16_MAX, std::max<int32_t>(INT16_MIN, vosEvent.m_x));
evt->where.v = std::min<int32_t>(INT16_MAX, std::max<int32_t>(INT16_MIN, vosEvent.m_y));
}
}
requeue = true;
}
else if (vosEvent.m_eventType == GpMouseEventTypes::kMove)
requeue = true;
if (requeue)
{
if (EventRecord *evt = queue->Enqueue())
{
evt->what = mouseMove;
evt->where.h = std::min<int32_t>(INT16_MAX, std::max<int32_t>(INT16_MIN, vosEvent.m_x));
evt->where.v = std::min<int32_t>(INT16_MAX, std::max<int32_t>(INT16_MIN, vosEvent.m_y));
}
if (TimeTaggedVOSEvent *evt = queue->Enqueue())
*evt = TimeTaggedVOSEvent::Create(vosEventBase, timestamp);
}
}
@@ -107,8 +96,10 @@ static void TranslateGamepadInputEvent(const GpGamepadInputEvent &vosEvent, Port
PL_DEAD(queue);
}
static void TranslateKeyboardInputEvent(const GpKeyboardInputEvent &vosEvent, PortabilityLayer::EventQueue *queue)
static void TranslateKeyboardInputEvent(const GpVOSEvent &vosEventBase, uint32_t timestamp, PortabilityLayer::EventQueue *queue)
{
const GpKeyboardInputEvent &vosEvent = vosEventBase.m_event.m_keyboardInputEvent;
PL_STATIC_ASSERT((1 << PL_INPUT_PLAYER_INDEX_BITS) >= PL_INPUT_MAX_PLAYERS);
PL_STATIC_ASSERT((1 << PL_INPUT_TYPE_CODE_BITS) >= KeyEventType_Count);
@@ -117,74 +108,51 @@ static void TranslateKeyboardInputEvent(const GpKeyboardInputEvent &vosEvent, Po
if (vosEvent.m_eventType == GpKeyboardInputEventTypes::kUp || vosEvent.m_eventType == GpKeyboardInputEventTypes::kDown)
inputManager->ApplyKeyboardEvent(vosEvent);
intptr_t msg = 0;
if (TimeTaggedVOSEvent *evt = queue->Enqueue())
*evt = TimeTaggedVOSEvent::Create(vosEventBase, timestamp);
}
intptr_t PackVOSKeyCode(const GpKeyboardInputEvent &vosEvent)
{
switch (vosEvent.m_keyIDSubset)
{
case GpKeyIDSubsets::kASCII:
msg = PL_KEY_ASCII(vosEvent.m_key.m_asciiChar);
break;
return PL_KEY_ASCII(vosEvent.m_key.m_asciiChar);
case GpKeyIDSubsets::kFKey:
msg = PL_KEY_FKEY(vosEvent.m_key.m_fKey);
break;
return PL_KEY_FKEY(vosEvent.m_key.m_fKey);
case GpKeyIDSubsets::kNumPadNumber:
msg = PL_KEY_NUMPAD_NUMBER(vosEvent.m_key.m_numPadNumber);
break;
return PL_KEY_NUMPAD_NUMBER(vosEvent.m_key.m_numPadNumber);
case GpKeyIDSubsets::kSpecial:
msg = PL_KEY_SPECIAL_ENCODE(vosEvent.m_key.m_specialKey);
return PL_KEY_SPECIAL_ENCODE(vosEvent.m_key.m_specialKey);
break;
case GpKeyIDSubsets::kNumPadSpecial:
msg = PL_KEY_NUMPAD_SPECIAL_ENCODE(vosEvent.m_key.m_numPadSpecialKey);
return PL_KEY_NUMPAD_SPECIAL_ENCODE(vosEvent.m_key.m_numPadSpecialKey);
break;
case GpKeyIDSubsets::kUnicode:
for (int i = 128; i < 256; i++)
{
if (PortabilityLayer::MacRoman::g_toUnicode[i] == vosEvent.m_key.m_unicodeChar)
{
msg = PL_KEY_MACROMAN(i);
break;
}
return PL_KEY_MACROMAN(i);
}
break;
case GpKeyIDSubsets::kGamepadButton:
msg = PL_KEY_GAMEPAD_BUTTON_ENCODE(vosEvent.m_key.m_gamepadKey.m_button, vosEvent.m_key.m_gamepadKey.m_player);
break;
return PL_KEY_GAMEPAD_BUTTON_ENCODE(vosEvent.m_key.m_gamepadKey.m_button, vosEvent.m_key.m_gamepadKey.m_player);
default:
PL_NotYetImplemented();
return 0;
}
if (msg == 0)
return;
EventRecord *evt = queue->Enqueue();
switch (vosEvent.m_eventType)
{
case GpKeyboardInputEventTypes::kUp:
evt->what = keyUp;
break;
case GpKeyboardInputEventTypes::kDown:
evt->what = keyUp;
break;
case GpKeyboardInputEventTypes::kAuto:
evt->what = autoKey;
break;
};
evt->message = msg;
PL_NotYetImplemented_TODO("Modifiers");
return 0;
}
static void TranslateVOSEvent(const GpVOSEvent *vosEvent, PortabilityLayer::EventQueue *queue)
static void TranslateVOSEvent(const GpVOSEvent *vosEvent, uint32_t timestamp, PortabilityLayer::EventQueue *queue)
{
switch (vosEvent->m_eventType)
{
case GpVOSEventTypes::kMouseInput:
TranslateMouseInputEvent(vosEvent->m_event.m_mouseInputEvent, queue);
TranslateMouseInputEvent(*vosEvent, timestamp, queue);
break;
case GpVOSEventTypes::kKeyboardInput:
TranslateKeyboardInputEvent(vosEvent->m_event.m_keyboardInputEvent, queue);
TranslateKeyboardInputEvent(*vosEvent, timestamp, queue);
break;
case GpVOSEventTypes::kGamepadInput:
TranslateGamepadInputEvent(vosEvent->m_event.m_gamepadInputEvent, queue);
@@ -192,14 +160,14 @@ static void TranslateVOSEvent(const GpVOSEvent *vosEvent, PortabilityLayer::Even
}
}
static void ImportVOSEvents()
static void ImportVOSEvents(uint32_t timestamp)
{
PortabilityLayer::EventQueue *plQueue = PortabilityLayer::EventQueue::GetInstance();
PortabilityLayer::HostVOSEventQueue *evtQueue = PortabilityLayer::HostVOSEventQueue::GetInstance();
while (const GpVOSEvent *evt = evtQueue->GetNext())
{
TranslateVOSEvent(evt, plQueue);
TranslateVOSEvent(evt, timestamp, plQueue);
evtQueue->DischargeOne();
}
}
@@ -283,7 +251,7 @@ void Delay(int ticks, UInt32 *endTickCount)
PortabilityLayer::SuspendApplication(PortabilityLayer::HostSuspendCallID_Delay, args, nullptr);
ImportVOSEvents();
ImportVOSEvents(PortabilityLayer::DisplayDeviceManager::GetInstance()->GetTickCount());
}
if (endTickCount)
@@ -436,30 +404,6 @@ void SetWTitle(WindowPtr window, const PLPasStr &title)
PL_NotYetImplemented();
}
bool PeekNextEvent(int32_t eventMask, EventRecord *event)
{
assert(eventMask == everyEvent); // We don't support other use cases
PortabilityLayer::EventQueue *queue = PortabilityLayer::EventQueue::GetInstance();
const EventRecord *record = queue->Peek();
if (record)
{
*event = *record;
return PL_TRUE;
}
else
return PL_FALSE;
}
bool GetNextEvent(int32_t eventMask, EventRecord *event)
{
assert(eventMask == everyEvent); // We don't support other use cases
PortabilityLayer::EventQueue *queue = PortabilityLayer::EventQueue::GetInstance();
return queue->Dequeue(event) ? PL_TRUE : PL_FALSE;
}
long MenuSelect(Point point)
{
int16_t menuID = 0;
@@ -481,7 +425,7 @@ long TickCount()
return PortabilityLayer::DisplayDeviceManager::GetInstance()->GetTickCount();
}
void GetKeys(KeyMap &keyMap)
void GetKeys(KeyDownStates &keyMap)
{
PortabilityLayer::InputManager::GetInstance()->GetKeys(keyMap);
}
@@ -496,7 +440,7 @@ short HiWord(Int32 v)
return (((v >> 16) ^ 0x8000) & 0xffff) - 0x8000;
}
static bool BitTestEitherSpecial(const KeyMap &keyMap, int eitherSpecial)
static bool BitTestEitherSpecial(const KeyDownStates &keyMap, int eitherSpecial)
{
switch (eitherSpecial)
{
@@ -512,7 +456,7 @@ static bool BitTestEitherSpecial(const KeyMap &keyMap, int eitherSpecial)
}
}
bool BitTst(const KeyMap &keyMap, int encodedKey)
bool BitTst(const KeyDownStates &keyMap, int encodedKey)
{
const KeyEventType evtType = PL_KEY_GET_EVENT_TYPE(encodedKey);
const int evtValue = PL_KEY_GET_VALUE(encodedKey);
@@ -947,23 +891,22 @@ void BlockMove(const void *src, void *dest, Size size)
memcpy(dest, src, size);
}
Boolean WaitNextEvent(int eventMask, EventRecord *eventOut, long sleep, void *unknown)
bool WaitForEvent(TimeTaggedVOSEvent *eventOut, uint32_t ticks)
{
for (;;)
{
Boolean hasEvent = GetNextEvent(eventMask, eventOut);
if (hasEvent)
return hasEvent;
if (PortabilityLayer::EventQueue::GetInstance()->Dequeue(eventOut))
return true;
Delay(1, nullptr);
if (sleep == 0)
if (ticks == 0)
break;
sleep--;
ticks--;
}
return PL_FALSE;
return false;
}
void DrawControls(WindowPtr window)

15
PortabilityLayer/PLCore.h
View File

@@ -14,6 +14,8 @@
#endif
struct IGpColorCursor;
struct GpVOSEvent;
struct TimeTaggedVOSEvent;
namespace PortabilityLayer
{
@@ -177,7 +179,7 @@ typedef THandle<VersionRecord> VersRecHndl;
typedef WindowPtr WindowRef; // wtf?
struct KeyMap;
struct KeyDownStates;
enum RegionID
{
@@ -277,18 +279,15 @@ void MoveWindow(WindowPtr window, int x, int y, Boolean moveToFront);
void ShowWindow(WindowPtr window);
void SetWTitle(WindowPtr window, const PLPasStr &title);
bool PeekNextEvent(int32_t eventMask, EventRecord *event);
bool GetNextEvent(int32_t eventMask, EventRecord *event);
long MenuSelect(Point point); // Breaks into menu select routine (in practice we'll just forward one from the queue?)
long MenuKey(int charCode);
long TickCount();
void GetKeys(KeyMap &keyMap);
void GetKeys(KeyDownStates &keyMap);
short LoWord(Int32 v);
short HiWord(Int32 v);
bool BitTst(const KeyMap &keyMap, int bit);
bool BitTst(const KeyDownStates &keyMap, int bit);
void NumToString(long number, unsigned char *str);
void ParamText(const PLPasStr &title, const PLPasStr &a, const PLPasStr &b, const PLPasStr &c);
@@ -338,11 +337,9 @@ void *NewPtr(Size size);
void *NewPtrClear(Size size);
void DisposePtr(void *ptr);
void PurgeSpace(long *totalFree, long *contiguousFree);
void BlockMove(const void *src, void *dest, Size size);
Boolean WaitNextEvent(int eventMask, EventRecord *eventOut, long sleep, void *unknown);
bool WaitForEvent(TimeTaggedVOSEvent *evt, uint32_t ticks);
void DrawControls(WindowPtr window);
void DrawGrowIcon(WindowPtr window);

19
PortabilityLayer/PLEventQueue.cpp
View File

@@ -1,4 +1,5 @@
#include "PLEventQueue.h"
#include "PLTimeTaggedVOSEvent.h"
#include <stdint.h>
@@ -10,16 +11,16 @@ namespace PortabilityLayer
EventQueueImpl();
~EventQueueImpl();
bool Dequeue(EventRecord *evt) override;
const EventRecord *Peek() const override;
EventRecord *Enqueue() override;
bool Dequeue(TimeTaggedVOSEvent *evt) override;
const TimeTaggedVOSEvent *Peek() const override;
TimeTaggedVOSEvent *Enqueue() override;
static EventQueueImpl *GetInstance();
private:
static const size_t kMaxEvents = 10000;
EventRecord m_events[kMaxEvents];
TimeTaggedVOSEvent m_events[kMaxEvents];
size_t m_firstEvent;
size_t m_numQueuedEvents;
@@ -36,7 +37,7 @@ namespace PortabilityLayer
{
}
bool EventQueueImpl::Dequeue(EventRecord *evt)
bool EventQueueImpl::Dequeue(TimeTaggedVOSEvent *evt)
{
if (m_numQueuedEvents == 0)
return false;
@@ -53,7 +54,7 @@ namespace PortabilityLayer
return true;
}
const EventRecord *EventQueueImpl::Peek() const
const TimeTaggedVOSEvent *EventQueueImpl::Peek() const
{
if (m_numQueuedEvents == 0)
return nullptr;
@@ -62,7 +63,7 @@ namespace PortabilityLayer
}
EventRecord *EventQueueImpl::Enqueue()
TimeTaggedVOSEvent *EventQueueImpl::Enqueue()
{
if (m_numQueuedEvents == kMaxEvents)
return nullptr;
@@ -73,8 +74,8 @@ namespace PortabilityLayer
m_numQueuedEvents++;
EventRecord *evt = m_events + nextEvent;
memset(evt, 0, sizeof(EventRecord));
TimeTaggedVOSEvent *evt = m_events + nextEvent;
memset(evt, 0, sizeof(TimeTaggedVOSEvent));
return evt;
}

8
PortabilityLayer/PLEventQueue.h
View File

@@ -4,14 +4,16 @@
#include <stdint.h>
struct TimeTaggedVOSEvent;
namespace PortabilityLayer
{
class EventQueue
{
public:
virtual bool Dequeue(EventRecord *evt) = 0;
virtual const EventRecord *Peek() const = 0;
virtual EventRecord *Enqueue() = 0;
virtual bool Dequeue(TimeTaggedVOSEvent *evt) = 0;
virtual const TimeTaggedVOSEvent *Peek() const = 0;
virtual TimeTaggedVOSEvent *Enqueue() = 0;
static EventQueue *GetInstance();
};

10
PortabilityLayer/PLKeyEncoding.h
View File

@@ -3,6 +3,8 @@
#include "GpVOSEvent.h"
#include "GpBitfield.h"
struct GpKeyboardInputEvent;
enum KeyEventType
{
KeyEventType_Special,
@@ -44,10 +46,12 @@ namespace KeyEventEitherSpecialCategories
#define PL_KEY_GAMEPAD_BUTTON(k, pl) ((KeyEventType_GamepadButton) | (pl << PL_INPUT_TYPE_CODE_BITS) | ((GpGamepadButtons::k) << (PL_INPUT_TYPE_CODE_BITS + PL_INPUT_PLAYER_INDEX_BITS)))
#define PL_KEY_GAMEPAD_BUTTON_ENCODE(k, pl) ((KeyEventType_GamepadButton) | (pl << PL_INPUT_TYPE_CODE_BITS) | ((k) << (PL_INPUT_TYPE_CODE_BITS + PL_INPUT_PLAYER_INDEX_BITS)))
#define PL_KEY_GET_EVENT_TYPE(k) (static_cast<KeyEventType>(k & ((1 << PL_INPUT_TYPE_CODE_BITS) - 1)))
#define PL_KEY_GET_VALUE(k) ((k) >> PL_INPUT_TYPE_CODE_BITS)
#define PL_KEY_GET_EVENT_TYPE(k) (static_cast<KeyEventType>(k & ((1 << PL_INPUT_TYPE_CODE_BITS) - 1)))
#define PL_KEY_GET_VALUE(k) ((k) >> PL_INPUT_TYPE_CODE_BITS)
struct KeyMap
intptr_t PackVOSKeyCode(const GpKeyboardInputEvent &evt);
struct KeyDownStates
{
GpBitfield<GpKeySpecials::kCount> m_special;
GpBitfield<128> m_ascii;

22
PortabilityLayer/PLTimeTaggedVOSEvent.cpp Normal file
View File

@@ -0,0 +1,22 @@
#include "PLTimeTaggedVOSEvent.h"
// Helpers for common cases
bool TimeTaggedVOSEvent::IsKeyDownEvent() const
{
if (m_vosEvent.m_eventType != GpVOSEventTypes::kKeyboardInput)
return false;
const GpKeyboardInputEvent &keyboardEvent = m_vosEvent.m_event.m_keyboardInputEvent;
return keyboardEvent.m_eventType == GpKeyboardInputEventTypes::kDown;
}
bool TimeTaggedVOSEvent::IsLMouseDownEvent() const
{
if (m_vosEvent.m_eventType != GpVOSEventTypes::kMouseInput)
return false;
const GpMouseInputEvent &mouseEvent = m_vosEvent.m_event.m_mouseInputEvent;
return mouseEvent.m_eventType == GpMouseEventTypes::kDown && mouseEvent.m_button == GpMouseButtons::kLeft;
}

24
PortabilityLayer/PLTimeTaggedVOSEvent.h Normal file
View File

@@ -0,0 +1,24 @@
#pragma once
#include "GpVOSEvent.h"
struct TimeTaggedVOSEvent
{
GpVOSEvent m_vosEvent;
uint32_t m_timestamp;
static TimeTaggedVOSEvent Create(const GpVOSEvent &vosEvent, uint32_t timestamp);
// Helpers for common cases
bool IsKeyDownEvent() const;
bool IsLMouseDownEvent() const;
};
inline TimeTaggedVOSEvent TimeTaggedVOSEvent::Create(const GpVOSEvent &vosEvent, uint32_t timestamp)
{
TimeTaggedVOSEvent result;
result.m_vosEvent = vosEvent;
result.m_timestamp = timestamp;
return result;
}

2
PortabilityLayer/PortabilityLayer.vcxproj
View File

@@ -203,6 +203,7 @@
<ClInclude Include="MenuManager.h" />
<ClInclude Include="PlotDirection.h" />
<ClInclude Include="PLStandardColors.h" />
<ClInclude Include="PLTimeTaggedVOSEvent.h" />
<ClInclude Include="ResolvedColor.h" />
<ClInclude Include="ScanlineMaskBuilder.h" />
<ClInclude Include="ScanlineMaskConverter.h" />
@@ -308,6 +309,7 @@
<ClCompile Include="PLSound.cpp" />
<ClCompile Include="PLStandardColors.cpp" />
<ClCompile Include="PLStringCompare.cpp" />
<ClCompile Include="PLTimeTaggedVOSEvent.cpp" />
<ClCompile Include="ScanlineMask.cpp" />
<ClCompile Include="ScanlineMaskBuilder.cpp" />
<ClCompile Include="ScanlineMaskConverter.cpp" />

6
PortabilityLayer/PortabilityLayer.vcxproj.filters
View File

@@ -408,6 +408,9 @@
<ClInclude Include="PLArrayViewIterator.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="PLTimeTaggedVOSEvent.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="CFileStream.cpp">
@@ -617,5 +620,8 @@
<ClCompile Include="PLStandardColors.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="PLTimeTaggedVOSEvent.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
</Project>

12
PortabilityLayer/WindowManager.cpp
View File

@@ -168,12 +168,6 @@ namespace PortabilityLayer
return nullptr;
}
if (EventRecord *evt = PortabilityLayer::EventQueue::GetInstance()->Enqueue())
{
evt->what = updateEvt;
evt->message = reinterpret_cast<intptr_t>(static_cast<Window*>(window));
}
return window;
}
@@ -312,12 +306,6 @@ namespace PortabilityLayer
void WindowManagerImpl::ResizeWindow(Window *window, int width, int height)
{
static_cast<WindowImpl*>(window)->Resize(width, height);
if (EventRecord *evt = PortabilityLayer::EventQueue::GetInstance()->Enqueue())
{
evt->what = updateEvt;
evt->message = reinterpret_cast<intptr_t>(window);
}
}
void WindowManagerImpl::MoveWindow(Window *window, int x, int y)