//  common.c
//
//  by John D. de Boer

#include "common.h"


#define SCHRAPLEN 30  //  maximum number of sizes of blocks kept
#define MAXSCHRAP 8   //  maximum number kept of each size

static int  SCHRAPNEL[SCHRAPLEN],SCHRAPDISP[SCHRAPLEN];
static void *Schrapnel[SCHRAPLEN][MAXSCHRAP];

static WindowRef       HaltDlg,ErrDlg,NoteDlg,TextDlg;
static EventHandlerUPP ModalHandler;
static bool            ModalOkay;

static void ***Space;  //  sorting space


//  System error message strings

  char *osmemerrormsg(int E) {
switch (E) {
case memFullErr:   return "not enough room in heap zone";
case memLockedErr: return "block is locked";
case memPurErr:    return "attempt to purge a locked block";
case memWZErr:     return "attempt to operate on a free block";
case nilHandleErr: return "NULL master pointer";
case memROZErr:    return "operation on a read-only zone";
} return NULL; }


//  Text controls

  ControlRef gettextcontrol(WindowRef W, OSType Sig, SInt32 ID) {
ControlID CID; OSStatus err; ControlRef C;
CID.signature=Sig; CID.id=ID; err=GetControlByID(W,&CID,&C);
if (err!=noErr) return NULL; return C; }

  void setstatictext(ControlRef C, const char *S) {
OSErr err; Size SIZE; if (!C) return; SIZE=length(S);
err=SetControlData(C,kControlEntireControl,kControlStaticTextTextTag,SIZE,S); }

  void setedittext(ControlRef C, const char *S, bool Sel) {
OSErr err; Size SIZE; ControlEditTextSelectionRec Rec;
if (!C) return; SIZE=length(S);
err=SetControlData(C,kControlEntireControl,kControlEditTextTextTag,SIZE,S);
if (Sel) {
  Rec.selStart=0; Rec.selEnd=SIZE;
  err=SetControlData(C,kControlEntireControl,kControlEditTextSelectionTag,sizeof(ControlEditTextSelectionRec),&Rec);
} }

  void getedittext(ControlRef C, char **S) {
OSErr err; Size SIZE,ACTUAL; if (!C || !S) return;
if (*S) old(*S); *S=NULL;
err=GetControlDataSize(C,kControlEntireControl,kControlEditTextTextTag,&SIZE);
if (err!=noErr || SIZE<=0) return;
*S=pointer((SIZE + 1) * sizeof(char));
err=GetControlData(C,kControlEntireControl,kControlEditTextTextTag,SIZE,*S,&ACTUAL);
(*S)[SIZE]=0; }


//  Basic dialog boxes

  bool modalokay(void) {
return ModalOkay; }

  static OSStatus modalcommandhandler(EventHandlerCallRef CallRef, EventRef E, void *UserData) {
OSStatus err; WindowRef WP; HICommand C;
err=GetEventParameter(E,kEventParamDirectObject,typeHICommand,NULL,sizeof(HICommand),NULL,&C);
WP=FrontNonFloatingWindow();
switch (C.commandID) {
  case 'quit': quit(); return noErr;
  case 'ok  ': QuitAppModalLoopForWindow(WP); ModalOkay=1; return noErr;
  case 'not!': QuitAppModalLoopForWindow(WP); ModalOkay=0; return noErr;
} return eventNotHandledErr; }

  void initnibdialog(IBNibRef Nib, const char *Name, WindowRef *WP) {
OSStatus err; EventTargetRef Target; EventTypeSpec ET; bool CantErr;
CantErr=(ErrDlg==NULL);
if (!Nib)  { if (CantErr) quit(); else error("initnibdialog() error #1"); return; }
if (!Name) { if (CantErr) quit(); else error("initnibdialog() error #2"); return; }
if (!WP)   { if (CantErr) quit(); else error("initnibdialog() error #3"); return; }
err=CreateWindowFromNib(Nib,macstring(Name),WP);
if (err) { if (CantErr) quit(); else error("initnibdialog() error #4"); return; }
Target=GetWindowEventTarget(*WP); err=InstallStandardEventHandler(Target);
if (err) { if (CantErr) quit(); else error("initnibdialog() error #5"); return; }
ET.eventClass=kEventClassCommand; ET.eventKind=kEventCommandProcess;
err=InstallWindowEventHandler(*WP,ModalHandler,1,&ET,NULL,NULL);
if (err) { if (CantErr) quit(); else error("initnibdialog() error #6"); return; } }

  void halt(const char *Msg) {
OSStatus err; ControlRef Statement;
Statement=gettextcontrol(HaltDlg,'stxt',0); setstatictext(Statement,Msg);
ShowWindow(HaltDlg); SelectWindow(HaltDlg); beep();
err=RunAppModalLoopForWindow(HaltDlg); }

  void error(const char *Msg) {
OSStatus err; ControlRef Statement;
Statement=gettextcontrol(ErrDlg,'stxt',0); setstatictext(Statement,Msg);
ShowWindow(ErrDlg); SelectWindow(ErrDlg); beep();
err=RunAppModalLoopForWindow(ErrDlg); HideWindow(ErrDlg); }

  void notification(const char *Msg) {
OSStatus err; ControlRef Statement;
Statement=gettextcontrol(NoteDlg,'stxt',0); setstatictext(Statement,Msg);
ShowWindow(NoteDlg); SelectWindow(NoteDlg); beep();
err=RunAppModalLoopForWindow(NoteDlg); HideWindow(NoteDlg); }

  bool modaltextentry(const char *Msg, char **S) {
ControlRef Question,Reply; OSStatus err; OSErr e; if (!Msg || !S) return 0;
Question=gettextcontrol(TextDlg,'stxt',0); setstatictext(Question,Msg);
Reply=gettextcontrol(TextDlg,'etxt',0); setedittext(Reply,*S,1);
ShowWindow(TextDlg); SelectWindow(TextDlg);
e=SetKeyboardFocus(TextDlg,Reply,kControlEntireControl);
err=RunAppModalLoopForWindow(TextDlg); HideWindow(TextDlg);
getedittext(Reply,S); return 1; }


//  Dynamic memory allocation

  static void memhalt(int E) {
char *M; M=osmemerrormsg(E); if (!M) M="Unknown Memory Manager error"; halt(M); }

  static void checkmemerror(void) {
int E; E=MemError(); if (E!=noErr) memhalt(E); }

  void *pointer(ulong N) {
ulong SL; void *P; int E; if (N<1L) return NULL; SL= (N - 1L) >> 2;
if (SL<SCHRAPLEN && SCHRAPNEL[SL]) return Schrapnel[SL][--SCHRAPNEL[SL]];
P=NewPtr((SL + 1L) << 2); E=MemError();
//if (!Must && (E==memFullErr || !P)) return NULL;
if (E) memhalt(E); if (!P) halt("Memory Allocation Error #1");
return P; }

  void old(void *P) {
long PS,SL; bool Range; if (!P) return; PS=GetPtrSize(P); checkmemerror();
if (PS<4L) halt("Memory Allocation Error #2");
SL= (PS - 1L) >> 2; Range= SL>=0 && SL<SCHRAPLEN;
if (Range && SCHRAPNEL[SL]<MAXSCHRAP) { Schrapnel[SL][SCHRAPNEL[SL]++]=P; return; }
DisposePtr(P); checkmemerror(); if (Range) SCHRAPDISP[SL]++; }

  void **handle(ulong N) {
void **H;
H=(void **)NewHandle(N);
checkmemerror();
if (!H) /*{ if (Must)*/ halt("Memory Allocation Error #3"); //return NULL; }
//MoveHHi((Handle)H);
checkmemerror(); return H; }

  void releasehandle(void **H) {
if (!H) return;//halt("Memory Allocation Error #4");
DisposeHandle((Handle)H); checkmemerror(); }

  void lockhandle(void **H) {
HLock((Handle)H); checkmemerror(); }

  void unlockhandle(void **H) {
HUnlock((Handle)H); checkmemerror(); }

/*  void purgeablehandle(void **H) {
HPurge((Handle)H); checkmemerror(); }

  void unpurgeablehandle(void **H) {
HNoPurge((Handle)H); checkmemerror(); }*/

  void resizevoidhandle(void **H, ulong SIZE) {
if (!H || !*H) halt("resizehandle() error #1");
SetHandleSize((Handle)H,SIZE); checkmemerror(); }

  void minimumsizehandle(void **H, ulong N, ulong SIZE) {
ulong ACTUAL,DESIRED; if (!H || !*H) halt("minimumsize() error #1");
ACTUAL=GetHandleSize((Handle)H); checkmemerror(); DESIRED= N * SIZE;
if (DESIRED>ACTUAL) resizehandle(H,DESIRED + (16L * SIZE)); }

  void fuzzyresizehandle(void **H, ulong N, ulong SIZE) {
ulong ACTUAL,DESIRED; if (!H || !*H) halt("fuzzyresize() error #1");
ACTUAL=GetHandleSize((Handle)H); checkmemerror(); DESIRED= N * SIZE;
if (DESIRED < ACTUAL / 2) resizehandle(H,ACTUAL / 2);
else if (DESIRED>ACTUAL) resizehandle(H,DESIRED + (16L * SIZE)); }


//  Sorting

  static void putinorder(void **List, void **Space, int NUM, orderprocptr InOrder) {
int HALF,TOP1,TOP2,i; bool First;
if (!List || !Space || NUM<2 || !InOrder) return;
HALF= NUM / 2; putinorder(List,Space,HALF,InOrder);
putinorder(List + HALF,Space + HALF,NUM - HALF,InOrder);
TOP1=0; TOP2=HALF;
for (i=0;i<NUM;i++) {
  First= TOP2>=NUM || (TOP1<HALF && InOrder(List[TOP1],List[TOP2]));
  Space[i]= First ? List[TOP1++] : List[TOP2++]; }
BlockMove(Space,List,NUM * sizeof(void *)); }

  void sortlist(void **List, int NUM, orderprocptr InOrder) {
minimumsize(Space,NUM,sizeof(void *)); lock(Space);
putinorder(List,*Space,NUM,InOrder); unlock(Space); }


//  Initialisation

  static bool MyIsAppearancePresent(void) {
OSStatus err; long response; bool Have;
err=Gestalt(gestaltAppearanceAttr,&response);
if (err) return false;
Have= response & (1 << gestaltAppearanceExists) ? true : false;
return Have; }

  void initmacintosh(void) {
int i; OSStatus err; IBNibRef Nib;

if (MyIsAppearancePresent()) RegisterAppearanceClient();

//InitCursor();
randomise(); initcolour();
for (i=0;i<SCHRAPLEN;i++) { SCHRAPNEL[i]=0; SCHRAPDISP[i]=0; }

ModalHandler=NewEventHandlerUPP(&modalcommandhandler);

err=CreateNibReference(CFSTR("halt"),&Nib);
initnibdialog(Nib,"Halt",&HaltDlg);
initnibdialog(Nib,"Error",&ErrDlg);
initnibdialog(Nib,"Notification",&NoteDlg);
initnibdialog(Nib,"TextEntry",&TextDlg);
DisposeNibReference(Nib);

Space=(void ***)handle(0); }