mirror of
https://github.com/autc04/Retro68.git
synced 2024-10-17 15:24:37 +00:00
621 lines
16 KiB
C++
621 lines
16 KiB
C++
/*
|
|
Copyright 2018 Wolfgang Thaller.
|
|
|
|
This file is part of Retro68.
|
|
|
|
Retro68 is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Retro68 is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Retro68. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <Quickdraw.h>
|
|
#include <Windows.h>
|
|
#include <Menus.h>
|
|
#include <Fonts.h>
|
|
#include <Resources.h>
|
|
#include <TextEdit.h>
|
|
#include <TextUtils.h>
|
|
#include <Dialogs.h>
|
|
#include <Devices.h>
|
|
#include <Traps.h>
|
|
#include <LowMem.h>
|
|
#include <SegLoad.h>
|
|
#include <Gestalt.h>
|
|
|
|
#include "MacSerialStream.h"
|
|
#include "AppLauncher.h"
|
|
#include "StatusDisplay.h"
|
|
|
|
#include <ReliableStream.h>
|
|
#include <ServerProtocol.h>
|
|
#include <Processes.h>
|
|
#include <string.h>
|
|
#include <memory>
|
|
|
|
#include <UnreliableStream.h>
|
|
|
|
enum
|
|
{
|
|
kMenuApple = 128,
|
|
kMenuFile,
|
|
kMenuEdit,
|
|
kMenuSpeed
|
|
};
|
|
|
|
enum
|
|
{
|
|
kItemAbout = 1,
|
|
|
|
kItemQuit = 1
|
|
};
|
|
|
|
struct Prefs
|
|
{
|
|
long baud = 19200;
|
|
bool inSubLaunch = false;
|
|
};
|
|
|
|
Prefs gPrefs;
|
|
bool gQuitting = false;
|
|
|
|
void SetBaud(long baud);
|
|
|
|
void ShowAboutBox()
|
|
{
|
|
WindowRef w = GetNewWindow(128, NULL, (WindowPtr) -1);
|
|
#if !TARGET_API_MAC_CARBON
|
|
MacMoveWindow(w,
|
|
qd.screenBits.bounds.right/2 - w->portRect.right/2,
|
|
qd.screenBits.bounds.bottom/2 - w->portRect.bottom/2,
|
|
false);
|
|
#endif
|
|
ShowWindow(w);
|
|
#if TARGET_API_MAC_CARBON
|
|
SetPortWindowPort(w);
|
|
#else
|
|
SetPort(w);
|
|
#endif
|
|
|
|
Handle h = GetResource('TEXT', 128);
|
|
HLock(h);
|
|
#if TARGET_API_MAC_CARBON
|
|
Rect r;
|
|
GetWindowPortBounds(w,&r);
|
|
#else
|
|
Rect r = w->portRect;
|
|
#endif
|
|
InsetRect(&r, 10,10);
|
|
TETextBox(*h, GetHandleSize(h), &r, teJustLeft);
|
|
|
|
ReleaseResource(h);
|
|
while(!Button())
|
|
;
|
|
while(Button())
|
|
;
|
|
FlushEvents(everyEvent, 0);
|
|
DisposeWindow(w);
|
|
}
|
|
|
|
void UpdateMenus()
|
|
{
|
|
MenuRef m = GetMenu(kMenuFile);
|
|
WindowRef w = FrontWindow();
|
|
|
|
#if TARGET_API_MAC_CARBON
|
|
#define EnableItem EnableMenuItem
|
|
#define DisableItem DisableMenuItem
|
|
#endif
|
|
|
|
m = GetMenu(kMenuEdit);
|
|
if(w && GetWindowKind(w) < 0)
|
|
{
|
|
// Desk accessory in front: Enable edit menu items
|
|
EnableItem(m,1);
|
|
EnableItem(m,3);
|
|
EnableItem(m,4);
|
|
EnableItem(m,5);
|
|
EnableItem(m,6);
|
|
}
|
|
else
|
|
{
|
|
// Application window or nothing in front, disable edit menu
|
|
DisableItem(m,1);
|
|
DisableItem(m,3);
|
|
DisableItem(m,4);
|
|
DisableItem(m,5);
|
|
DisableItem(m,6);
|
|
}
|
|
|
|
m = GetMenu(kMenuSpeed);
|
|
for(int i = 1; i <= CountMenuItems(m); i++)
|
|
{
|
|
Str255 str;
|
|
long baud;
|
|
GetMenuItemText(m, i, str);
|
|
StringToNum(str, &baud);
|
|
CheckMenuItem(m, i, baud == gPrefs.baud);
|
|
}
|
|
}
|
|
|
|
void DoMenuCommand(long menuCommand)
|
|
{
|
|
Str255 str;
|
|
WindowRef w;
|
|
short menuID = menuCommand >> 16;
|
|
short menuItem = menuCommand & 0xFFFF;
|
|
if(menuID == kMenuApple)
|
|
{
|
|
if(menuItem == kItemAbout)
|
|
ShowAboutBox();
|
|
#if !TARGET_API_MAC_CARBON
|
|
else
|
|
{
|
|
GetMenuItemText(GetMenu(128), menuItem, str);
|
|
OpenDeskAcc(str);
|
|
}
|
|
#endif
|
|
}
|
|
else if(menuID == kMenuFile)
|
|
{
|
|
switch(menuItem)
|
|
{
|
|
case kItemQuit:
|
|
gQuitting = true;
|
|
break;
|
|
}
|
|
}
|
|
else if(menuID == kMenuEdit)
|
|
{
|
|
#if !TARGET_API_MAC_CARBON
|
|
if(!SystemEdit(menuItem - 1))
|
|
#endif
|
|
{
|
|
// edit command not handled by desk accessory
|
|
}
|
|
}
|
|
else if(menuID == kMenuSpeed)
|
|
{
|
|
GetMenuItemText(GetMenu(menuID), menuItem, str);
|
|
StringToNum(str, &gPrefs.baud);
|
|
SetBaud(gPrefs.baud);
|
|
}
|
|
HiliteMenu(0);
|
|
}
|
|
|
|
std::unique_ptr<StatusDisplay> statusDisplay;
|
|
|
|
|
|
class LaunchServer : public StreamListener
|
|
{
|
|
Stream* stream;
|
|
|
|
uint32_t dataSize, rsrcSize;
|
|
uint32_t remainingSize;
|
|
short refNum;
|
|
public:
|
|
LaunchServer(Stream* stream) : stream(stream)
|
|
{
|
|
stream->setListener(this);
|
|
}
|
|
|
|
enum class State
|
|
{
|
|
command,
|
|
header,
|
|
data,
|
|
rsrc,
|
|
launch,
|
|
wait,
|
|
respond
|
|
};
|
|
State state = State::command;
|
|
RemoteCommand command;
|
|
|
|
OSType type, creator;
|
|
|
|
void onReset()
|
|
{
|
|
statusDisplay->SetStatus(AppStatus::ready, 0, 0);
|
|
state = State::command;
|
|
}
|
|
|
|
size_t onReceive(const uint8_t* p, size_t n)
|
|
{
|
|
switch(state)
|
|
{
|
|
case State::command:
|
|
{
|
|
if(n < 1)
|
|
return 0;
|
|
command = (RemoteCommand)p[0];
|
|
if(command == RemoteCommand::launchApp || command == RemoteCommand::upgradeLauncher)
|
|
state = State::header;
|
|
return 1;
|
|
}
|
|
|
|
case State::header:
|
|
{
|
|
if(n < 16)
|
|
return 0;
|
|
type = *(const OSType*)(p+0);
|
|
creator = *(const OSType*)(p+4);
|
|
dataSize = *(const uint32_t*)(p+8);
|
|
rsrcSize = *(const uint32_t*)(p+12);
|
|
|
|
statusDisplay->SetStatus(AppStatus::downloading, 0, dataSize + rsrcSize);
|
|
|
|
FSDelete("\pRetro68App", 0);
|
|
Create("\pRetro68App", 0, creator, type);
|
|
OpenDF("\pRetro68App", 0, &refNum);
|
|
FSDelete("\pout", 0);
|
|
Create("\pout", 0, 'ttxt', 'TEXT');
|
|
|
|
state = State::data;
|
|
remainingSize = dataSize;
|
|
return 16;
|
|
}
|
|
|
|
case State::data:
|
|
{
|
|
long count = n < remainingSize ? n : remainingSize;
|
|
|
|
FSWrite(refNum, &count, p);
|
|
remainingSize -= count;
|
|
|
|
statusDisplay->SetStatus(AppStatus::downloading, dataSize - remainingSize, dataSize + rsrcSize);
|
|
|
|
if(remainingSize)
|
|
return count;
|
|
|
|
FSClose(refNum);
|
|
OpenRF("\pRetro68App", 0, &refNum);
|
|
state = State::rsrc;
|
|
remainingSize = rsrcSize;
|
|
|
|
|
|
return count;
|
|
}
|
|
|
|
case State::rsrc:
|
|
{
|
|
long count = n < remainingSize ? n : remainingSize;
|
|
|
|
FSWrite(refNum, &count, p);
|
|
remainingSize -= count;
|
|
|
|
statusDisplay->SetStatus(AppStatus::downloading, dataSize + rsrcSize - remainingSize, dataSize + rsrcSize);
|
|
|
|
if(remainingSize)
|
|
return count;
|
|
|
|
FSClose(refNum);
|
|
|
|
statusDisplay->SetStatus(AppStatus::running);
|
|
|
|
state = State::launch;
|
|
return count;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
short outRefNum;
|
|
long outSize, outSizeRemaining;
|
|
MacSerialStream *gSerialStream;
|
|
int nullEventCounter = 0;
|
|
|
|
void SetBaud(long baud)
|
|
{
|
|
gSerialStream->setBaud(baud);
|
|
}
|
|
|
|
void StartResponding(LaunchServer& server, ReliableStream& rStream)
|
|
{
|
|
server.state = LaunchServer::State::respond;
|
|
uint32_t zero = 0;
|
|
rStream.write(&zero, 4);
|
|
|
|
OpenDF("\pout", 0, &outRefNum);
|
|
GetEOF(outRefNum, &outSize);
|
|
outSizeRemaining = outSize;
|
|
statusDisplay->SetStatus(AppStatus::uploading, 0, outSize);
|
|
|
|
rStream.write(&outSize, 4);
|
|
rStream.flushWrite();
|
|
}
|
|
|
|
void WritePrefs()
|
|
{
|
|
short refNum;
|
|
Create("\pLaunchAPPLServer Preferences", 0, 'R68L', 'LAPR');
|
|
if(OpenDF("\pLaunchAPPLServer Preferences", 0, &refNum) == noErr)
|
|
{
|
|
long count = sizeof(gPrefs);
|
|
FSWrite(refNum, &count, &gPrefs);
|
|
FSClose(refNum);
|
|
}
|
|
}
|
|
|
|
pascal OSErr aeRun (const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefcon)
|
|
{
|
|
return noErr;
|
|
}
|
|
pascal OSErr aeOpen (const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefcon)
|
|
{
|
|
return noErr;
|
|
}
|
|
pascal OSErr aePrint (const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefcon)
|
|
{
|
|
return noErr;
|
|
}
|
|
pascal OSErr aeQuit (const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefcon)
|
|
{
|
|
gQuitting = true;
|
|
return noErr;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
// default stack size is 8KB on B&W macs
|
|
// and 24 KB on Color macs.
|
|
// 8KB seems to be not quite enough,
|
|
// so increase stack size by 8KB.
|
|
SetApplLimit(GetApplLimit() - 8192);
|
|
MaxApplZone();
|
|
#if !TARGET_API_MAC_CARBON
|
|
InitGraf(&qd.thePort);
|
|
InitFonts();
|
|
InitWindows();
|
|
InitMenus();
|
|
TEInit();
|
|
InitDialogs(NULL);
|
|
#endif
|
|
|
|
#if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
|
|
short& ROM85 = *(short*) 0x028E;
|
|
Boolean is128KROM = (ROM85 > 0);
|
|
Boolean hasSysEnvirons = false;
|
|
Boolean hasWaitNextEvent = false;
|
|
Boolean hasGestalt = false;
|
|
Boolean hasAppleEvents = false;
|
|
if (is128KROM)
|
|
{
|
|
UniversalProcPtr trapUnimpl = GetToolTrapAddress(_Unimplemented);
|
|
UniversalProcPtr trapSysEnv = GetOSTrapAddress(_SysEnvirons);
|
|
UniversalProcPtr trapWaitNextEvent = GetToolTrapAddress(_WaitNextEvent);
|
|
UniversalProcPtr trapGestalt = GetOSTrapAddress(_Gestalt);
|
|
|
|
hasSysEnvirons = (trapSysEnv != trapUnimpl);
|
|
hasWaitNextEvent = (trapWaitNextEvent != trapUnimpl);
|
|
hasGestalt = (trapGestalt != trapUnimpl);
|
|
|
|
if(hasGestalt)
|
|
{
|
|
long response = 0;
|
|
OSErr err = Gestalt(gestaltAppleEventsAttr, &response);
|
|
hasAppleEvents = err == noErr && response != 0;
|
|
}
|
|
}
|
|
#else
|
|
const Boolean hasSysEnvirons = true;
|
|
const Boolean hasWaitNextEvent = true;
|
|
const Boolean hasGestalt = true;
|
|
const Boolean hasAppleEvents = true;
|
|
#endif
|
|
|
|
SetMenuBar(GetNewMBar(128));
|
|
AppendResMenu(GetMenu(128), 'DRVR');
|
|
DrawMenuBar();
|
|
|
|
InitCursor();
|
|
|
|
if(hasAppleEvents)
|
|
{
|
|
AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, NewAEEventHandlerUPP(&aeRun), 0, false);
|
|
AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerUPP(&aeOpen), 0, false);
|
|
AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, NewAEEventHandlerUPP(&aePrint), 0, false);
|
|
AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP(&aeQuit), 0, false);
|
|
}
|
|
|
|
statusDisplay = std::make_unique<StatusDisplay>();
|
|
|
|
{
|
|
short refNum;
|
|
if(OpenDF("\pLaunchAPPLServer Preferences", 0, &refNum) == noErr)
|
|
{
|
|
long count = sizeof(gPrefs);
|
|
FSRead(refNum, &count, &gPrefs);
|
|
FSClose(refNum);
|
|
}
|
|
}
|
|
|
|
MacSerialStream stream(gPrefs.baud);
|
|
gSerialStream = &stream;
|
|
|
|
//#define SIMULATE_ERRORS
|
|
#ifdef SIMULATE_ERRORS
|
|
UnreliableStream uStream(stream);
|
|
ReliableStream rStream(&uStream);
|
|
#else
|
|
ReliableStream rStream(&stream);
|
|
#endif
|
|
|
|
LaunchServer server(&rStream);
|
|
|
|
std::unique_ptr<AppLauncher> appLauncher;
|
|
|
|
if(gPrefs.inSubLaunch)
|
|
{
|
|
gPrefs.inSubLaunch = false;
|
|
StartResponding(server, rStream);
|
|
}
|
|
|
|
while(!gQuitting)
|
|
{
|
|
EventRecord e;
|
|
WindowRef win;
|
|
Boolean hadEvent;
|
|
|
|
#if !TARGET_API_MAC_CARBON
|
|
if(!hasWaitNextEvent)
|
|
{
|
|
SystemTask();
|
|
hadEvent = GetNextEvent(everyEvent, &e);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
hadEvent = WaitNextEvent(everyEvent, &e, 10, NULL);
|
|
}
|
|
|
|
if(hadEvent)
|
|
{
|
|
switch(e.what)
|
|
{
|
|
case keyDown:
|
|
if(e.modifiers & cmdKey)
|
|
{
|
|
UpdateMenus();
|
|
DoMenuCommand(MenuKey(e.message & charCodeMask));
|
|
}
|
|
break;
|
|
case mouseDown:
|
|
switch(FindWindow(e.where, &win))
|
|
{
|
|
case inGoAway:
|
|
if(TrackGoAway(win, e.where))
|
|
DisposeWindow(win);
|
|
break;
|
|
case inDrag:
|
|
DragWindow(win, e.where, &qd.screenBits.bounds);
|
|
break;
|
|
case inMenuBar:
|
|
UpdateMenus();
|
|
DoMenuCommand( MenuSelect(e.where) );
|
|
break;
|
|
case inContent:
|
|
SelectWindow(win);
|
|
break;
|
|
#if !TARGET_API_MAC_CARBON
|
|
case inSysWindow:
|
|
SystemClick(&e, win);
|
|
break;
|
|
#endif
|
|
}
|
|
break;
|
|
case updateEvt:
|
|
if(statusDisplay && (WindowRef)e.message == statusDisplay->GetWindow())
|
|
statusDisplay->Update();
|
|
break;
|
|
case kHighLevelEvent:
|
|
if(hasAppleEvents)
|
|
AEProcessAppleEvent(&e);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
nullEventCounter++;
|
|
|
|
if(server.state != LaunchServer::State::wait)
|
|
{
|
|
stream.idle();
|
|
statusDisplay->SetErrorCount(rStream.getFailedReceiveCount() + rStream.getFailedSendCount());
|
|
}
|
|
statusDisplay->Idle();
|
|
|
|
if(server.state == LaunchServer::State::launch)
|
|
{
|
|
gSerialStream->close();
|
|
UnloadSeg((void*) &MacSerialStream::unloadSegDummy);
|
|
gPrefs.inSubLaunch = true;
|
|
WritePrefs();
|
|
|
|
if(server.command == RemoteCommand::upgradeLauncher)
|
|
{
|
|
if(server.creator == 'R68L' && server.type == 'APPL')
|
|
{
|
|
FSDelete("\pLaunchAPPLServer.old", 0);
|
|
Rename(LMGetCurApName(), 0, "\pLaunchAPPLServer.old");
|
|
Rename("\pRetro68App", 0, LMGetCurApName());
|
|
|
|
LaunchParamBlockRec lpb;
|
|
memset(&lpb, 0, sizeof(lpb));
|
|
lpb.reserved1 = (unsigned long) LMGetCurApName();
|
|
lpb.reserved2 = 0;
|
|
OSErr err = LaunchApplication(&lpb);
|
|
ExitToShell();
|
|
}
|
|
}
|
|
|
|
if(server.type == 'MPST')
|
|
appLauncher = CreateToolLauncher();
|
|
else
|
|
appLauncher = CreateAppLauncher();
|
|
|
|
bool launched = appLauncher->Launch("\pRetro68App");
|
|
gPrefs.inSubLaunch = false;
|
|
WritePrefs();
|
|
|
|
if(launched)
|
|
{
|
|
server.state = LaunchServer::State::wait;
|
|
nullEventCounter = 0;
|
|
|
|
statusDisplay->SetStatus(AppStatus::running, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
server.state = LaunchServer::State::command;
|
|
gSerialStream->open();
|
|
statusDisplay->SetStatus(AppStatus::ready, 0, 0);
|
|
}
|
|
}
|
|
else if(server.state == LaunchServer::State::wait && nullEventCounter > 3)
|
|
{
|
|
if(!appLauncher->IsRunning("\pRetro68App"))
|
|
{
|
|
appLauncher.reset();
|
|
UnloadSeg((void*) &CreateAppLauncher);
|
|
UnloadSeg((void*) &CreateToolLauncher);
|
|
gSerialStream->open();
|
|
StartResponding(server, rStream);
|
|
}
|
|
}
|
|
else if(server.state == LaunchServer::State::respond)
|
|
{
|
|
while(outSizeRemaining && rStream.readyToWrite())
|
|
{
|
|
char buf[1024];
|
|
long count = outSizeRemaining > 1024 ? 1024 : outSizeRemaining;
|
|
FSRead(outRefNum, &count, buf);
|
|
rStream.write(buf, count);
|
|
outSizeRemaining -= count;
|
|
}
|
|
statusDisplay->SetStatus(AppStatus::uploading, outSize - outSizeRemaining, outSize);
|
|
|
|
if(outSizeRemaining == 0)
|
|
{
|
|
FSClose(outRefNum);
|
|
}
|
|
if(outSizeRemaining == 0 && rStream.allDataArrived())
|
|
{
|
|
server.state = LaunchServer::State::command;
|
|
statusDisplay->SetStatus(AppStatus::ready, 0, 0);
|
|
rStream.reset(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
WritePrefs();
|
|
return 0;
|
|
}
|