Macintosh-SW
/
eudora-mac
mirror of https://github.com/evilneuro/eudora-mac.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
eudora-mac/messact.c

1 line
96 KiB
C
Executable File
Raw Permalink Blame History

/* Copyright (c) 2017, Computer History Museum
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted (subject to
the limitations in the disclaimer below) provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Computer History Museum nor the names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE
COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE. */
#include "messact.h"
#define FILE_NUM 24
/* Copyright (c) 1990-1992 by the University of Illinois Board of Trustees */
#pragma segment Messact
OSErr MakeSubjectTXE(MessHandle messH);
void MessUpdate(MyWindowPtr win);
void MessSubjRect(MyWindowPtr win,Rect *r);
Boolean MessScroll(MyWindowPtr win,int h,int v);
void MessHelp(MyWindowPtr win,Point mouse);
short MyFSWrite(short refN,long *bytes,UPtr buffer);
Boolean IsAttLine(PStr line,Boolean wantToOpen);
OSErr OpenAttLine(PETEHandle pte,PStr line,Boolean finderSelect,Boolean printIt);
Boolean GetBlahRect(MyWindowPtr win, short which, Rect *r);
Boolean TogglePOPD(OSType theType,short id, MessHandle messH);
void SADL_Hilite(DialogPtr dgPtr);
void MessButton(MyWindowPtr win,ControlHandle button,long modifiers,short part);
void MessTxChanged(MyWindowPtr win,TEHandle teh,short oldNl,short newNl,Boolean scroll);
#define I_WIDTH 29
OSErr KillTransAttachments(FSSpecHandle files);
Boolean GetTruckRect(MyWindowPtr win,Rect *c);
void AddNotifyControls(MessHandle messH);
void PlaceNotifyControls(MyWindowPtr win);
static short SaveAsToOpenFileLo(short refN,MessHandle messH);
void MessProxy(MyWindowPtr win,EventRecord *event);
OSErr LopPoundHexDigits(PStr fileName);
#ifdef USECMM_BAD
OSErr MessBuildCMenu( MyWindowPtr win, EventRecord* contextEvent, CMenuInfoHndl* specCMenuInfo );
#endif
/**********************************************************************
* MessClose - close a message window
**********************************************************************/
Boolean MessClose(MyWindowPtr win)
{
MessType **messH = (MessType **)GetMyWindowPrivateData(win);
TOCType **tocH = (*messH)->tocH;
int sumNum = (*messH)->sumNum;
if (!GrowZoning && TheBody && (*messH)->subPTE && win->pte==(*messH)->subPTE)
MessFocus(messH,TheBody);
if (PeteIsDirty((*messH)->subPTE)) MessSaveSub(messH);
if (!GrowZoning) win->isDirty = win->isDirty || PeteIsDirtyList(TheBody);
if (!NoSaves && !GrowZoning)
if (!SaveMessHi(win,True)) return(False);
LL_Remove(MessList,messH,(MessType **));
AccuZap((*messH)->extras);
AccuZap((*messH)->aSourceMID);
if ((*messH)->etlFiles) KillTransAttachments((*messH)->etlFiles);
ZapHandle((*messH)->etlFiles);
SetMyWindowPrivateData (win, nil);
AccuZap((*messH)->newsGroupAcc);
ZapHandle(messH);
(*tocH)->sums[sumNum].messH = nil;
#ifdef IMAP
// Cancel the IMAP download if this is an imap message ...
if ((*tocH)->imapTOC) IMAPAbortMessageFetch(tocH, sumNum);
#endif
return(True);
}
/**********************************************************************
* SaveMessHi - save a message, if the user wants and if its dirty
**********************************************************************/
Boolean SaveMessHi(MyWindowPtr win,Boolean closing)
{
short which;
if (win->isDirty)
{
which = WannaSave(win);
if (which==CANCEL_ITEM) return(False);
else if (which == WANNA_SAVE_SAVE)
{
if (!SaveMess(win)) return(False);
}
else if (which == WANNA_SAVE_DISCARD)
{
if (!closing) ReopenMessage(win);
}
}
return(True);
}
/**********************************************************************
*
**********************************************************************/
OSErr KillTransAttachments(FSSpecHandle files)
{
FSSpec spec;
OSErr err, anyErr=noErr;
short n;
for (n=HandleCount(files);n;n--)
{
spec = (*files)[n-1];
err = WipeSpec(&spec);
if (!anyErr) anyErr = err;
}
return(anyErr);
}
/**********************************************************************
* NewPrior - compute a new priority from a menu and an old priorty
**********************************************************************/
short NewPrior(short item,short prior)
{
switch(item)
{
case pymRaise:
prior = Prior2Display(prior);
prior = MAX(pymHighest,prior-1);
prior = Display2Prior(prior);
break;
case pymLower:
prior = Prior2Display(prior);
prior = MIN(pymLowest,prior+1);
prior = Display2Prior(prior);
break;
default: prior = Display2Prior(item); break;
}
return(prior);
}
/************************************************************************
* TransferMenuChoice - handle a menu choice from a transfer menu
************************************************************************/
Boolean TransferMenuChoice(short menu,short item,TOCHandle tocH,short sumNum,long modifiers,Boolean fcc)
{
FSSpec spec, toSpec, resolvToSpec;
short function=REAL_BIG;
if (!IsMailboxChoice(menu,item)) return(False);
if (menu==TRANSFER_MENU)
function = TRANSFER;
else if (IsMailboxSubmenu(menu))
function = (menu-(g16bitSubMenuIDs?BOX_MENU_START:1))/MAX_BOX_LEVELS;
if (function == TRANSFER)
{
spec = GetMailboxSpec(tocH,sumNum);
if (GetTransferParams(menu,item,&toSpec,nil) && !SameSpec(&spec,&toSpec))
if (!ResolveAliasOrElse(&toSpec,&resolvToSpec,nil) && !SameSpec(&spec,&resolvToSpec))
{
//Folder Carbon Copy - no FCC in Light!
if (HasFeature (featureFcc) && fcc)
Fcc((*tocH)->sums[sumNum].messH,&toSpec);
else
if (sumNum>=0)
{
#ifdef TWO
if (!(modifiers&optionKey))
{
#ifdef IMAP
if (!(*tocH)->imapTOC)
#endif
AddXfUndo(tocH,TOCBySpec(&toSpec),sumNum);
EzOpen(tocH,sumNum,0,modifiers,True,True);
}
#endif
MoveMessage(tocH,sumNum,&toSpec,(modifiers&optionKey)!=0);
}
else
MoveSelectedMessages(tocH,&toSpec,(modifiers&optionKey)!=0);
}
return(True);
}
return(False);
}
/**********************************************************************
* TogglePOPD - put a message on or off a list,
**********************************************************************/
Boolean TogglePOPD(OSType theType,short id, MessHandle messH)
{
Boolean was;
if (was = IdIsOnPOPD(theType,id,SumOf(messH)->uidHash))
{
RemIdFromPOPD(theType,id,SumOf(messH)->uidHash);
}
else
{
AddIdToPOPD(theType,id,SumOf(messH)->uidHash,False);
}
return(!was);
}
/************************************************************************
* PetePaneDraw - draw a pete record in a user pane
************************************************************************/
pascal void PetePaneDraw(ControlHandle cntl, SInt16 part)
{
#pragma unused(part)
PETEHandle pte = (PETEHandle)GetControlReference(cntl);
PeteUpdate(pte);
}
/************************************************************************
* MakeSubjectTXE - make a TERec for the subject
************************************************************************/
OSErr MakeSubjectTXE(MessHandle messH)
{
Str63 subject;
Rect view;
MyWindowPtr win=(*messH)->win;
GrafPtr oldPort;
OSErr err;
PETEDocInitInfo pi;
PETEHandle pte;
ControlHandle cntl;
long offset = 0;
DECLARE_UPP(PetePaneDraw,ControlUserPaneDraw);
GetPort(&oldPort);
SetPort_(GetMyWindowCGrafPtr(win));
PSCopy(subject,SumOf(messH)->subj);
MessSubjRect(win,&view);
OffsetRect(&view,0,1);
DefaultPII(win,False,0,&pi);
pi.inRect = view;
pi.docWidth = MessWi(win)-9;
if (!(err=PeteCreate(win,&pte,peClearAllReturns,&pi)))
{
(*PeteExtra(pte))->frame = True;
if(!MessFlagIsSet(messH, FLAG_UTF8) ||
!HasUnicode() ||
EncodingError(err = PeteInsertIntlText(pte,&offset,(Handle)(subject+1),-1,*subject,nil,UTF8_ENCODING,false,true)))
{
err=PETEInsertTextPtr(PETE,pte,0,subject+1,*subject,nil);
}
if(MessFlagIsSet(messH, FLAG_UTF8) && !HasUnicode())
{
PeteLock(pte, 0, PeteLen(pte), peModLock);
}
PeteFontAndSize(pte,FontID,FontSize);
PETEMarkDocDirty(PETE,pte,False);
(*messH)->subPTE = pte;
if (cntl=NewControl(GetMyWindowWindowPtr(win),&view,"",True,0,0,0,kControlUserPaneProc,(uLong)pte))
{
INIT_UPP(PetePaneDraw,ControlUserPaneDraw);
SetControlData(cntl,0,kControlUserPaneDrawProcTag,sizeof(PetePaneDrawUPP),(void*)&PetePaneDrawUPP);
EmbedControl(cntl,win->topMarginCntl);
}
}
CleanPII(&pi);
if (err) WarnUser(PETE_ERR,err);
SetPort_(oldPort);
return(!err);
}
/************************************************************************
* AddXlateTables - add named translate tables to the current menu
************************************************************************/
short AddXlateTables(Boolean isOut,short nowId,Boolean ph,MenuHandle pmh)
{
Boolean added=CountMenuItems(pmh)==0;
short i,n;
Handle h;
Str31 name;
ResType type;
short id;
short defltId = ph ? 0 : GetPrefLong((isOut ? PREF_OUT_XLATE : PREF_IN_XLATE));
short item = 0;
n = CountResources('taBL');
SetResLoad(False);
for (i=1;i<=n;i++)
if (h=GetIndResource_('taBL',i))
{
GetResInfo(h,&id,&type,name);
ReleaseResource_(h);
if (!ResError() && *name && ((id%2)==0)==isOut)
{
if (!added)
{
added = True;
AppendMenu(pmh,"\p-");
}
MyAppendMenu(pmh,name);
if (id==defltId) SetItemStyle(pmh,CountMenuItems(pmh),outline);
if (id==nowId || (id==defltId && nowId==DEFAULT_TABLE))
{
item = CountMenuItems(pmh);
SetItemMark(pmh,CountMenuItems(pmh),checkMark);
}
}
}
SetResLoad(True);
return(item);
}
/************************************************************************
* Menu2TableId - what table id does a menu choice represent?
************************************************************************/
Boolean Menu2TableId(TOCHandle tocH,MenuHandle pmh,short item, short *tableId)
{
short newId;
short mark=0;
ResType type;
Str31 name;
Handle h;
Boolean isOut = (*tocH)->which == OUT;
Boolean makeDefault = 0!=(CurrentModifiers()&shiftKey);
if (makeDefault) GetItemStyle(pmh,item,(Style*)&mark);
else GetItemMark(pmh,item,&mark);
if (mark)
newId = NO_TABLE;
else
{
MyGetItem(pmh,item,name);
SetResLoad(False);
if (h=GetNamedResource('taBL',name))
{
GetResInfo(h,&newId,&type,name);
if (ResError()) newId = *tableId; /* do nothing */
ReleaseResource_(h);
}
SetResLoad(True);
}
if (makeDefault)
{
NumToString(newId,name);
SetPref((isOut?PREF_OUT_XLATE:PREF_IN_XLATE),name);
return(False);
}
else
{
*tableId = newId;
return(True);
}
}
/************************************************************************
* SetSubject - set the subject in a message summary
************************************************************************/
void SetSubject(TOCHandle tocH,short sumNum,PStr sub)
{
Str63 oldSubj;
Str255 title;
MessHandle messH = (*tocH)->sums[sumNum].messH;
PSCopy(oldSubj,(*tocH)->sums[sumNum].subj);
if (!EqualString(oldSubj,sub,True,True))
{
PSCopy((*tocH)->sums[sumNum].subj,sub);
InvalSum(tocH,sumNum);
#ifdef NEVER
CalcSumLengths(tocH,sumNum);
#endif
TOCSetDirty(tocH,true);
if (messH)
{
MakeMessTitle(title,tocH,sumNum,True);
SetWTitle_(GetMyWindowWindowPtr((*messH)->win),title);
if ((*messH)->subPTE)
{
if(MessFlagIsSet(messH,FLAG_UTF8) && HasUnicode())
PeteSetIntlText((*messH)->subPTE,sub+1,-1,*sub,nil,UTF8_ENCODING);
else
PeteSetTextPtr((*messH)->subPTE,sub+1,*sub);
}
}
SearchUpdateSum(tocH, sumNum, tocH, (*tocH)->sums[sumNum].serialNum, false, false); // Notify search window
}
}
/************************************************************************
* SetSender - set the sender in a message summary
************************************************************************/
void SetSender(TOCHandle tocH,short sumNum,PStr sender)
{
Str63 oldSender;
Str255 title;
MessHandle messH = (*tocH)->sums[sumNum].messH;
PCopy(oldSender,(*tocH)->sums[sumNum].from);
if (!EqualString(oldSender,sender,True,True))
{
PCopy((*tocH)->sums[sumNum].from,sender);
InvalSum(tocH,sumNum);
#ifdef NEVER
CalcSumLengths(tocH,sumNum);
#endif
TOCSetDirty(tocH,true);
if (messH)
{
MakeMessTitle(title,tocH,sumNum,True);
SetWTitle_(GetMyWindowWindowPtr((*messH)->win),title);
}
}
}
/************************************************************************
* SetFlag - set one of the message flags
************************************************************************/
void SetFlag(TOCHandle tocH,short sumNum,long flag,Boolean on)
{
if (on)
(*tocH)->sums[sumNum].flags |= flag;
else
(*tocH)->sums[sumNum].flags &= ~flag;
if ((*tocH)->sums[sumNum].messH)
InvalTopMargin((*(*tocH)->sums[sumNum].messH)->win);
TOCSetDirty(tocH,true);
}
/************************************************************************
* SetOpt - set one of the message options
************************************************************************/
void SetOpt(TOCHandle tocH,short sumNum,long flag,Boolean on)
{
if (on)
(*tocH)->sums[sumNum].opts |= flag;
else
(*tocH)->sums[sumNum].opts &= ~flag;
TOCSetDirty(tocH,true);
}
#ifdef TWO
/************************************************************************
* OpenSelectedAtt - open selected attachments (or tell if attachments are selected)
************************************************************************/
Boolean AttIsSelected(MyWindowPtr win,PETEHandle pte,long startWith,long endWith,short what,long *aStart, long *aEnd)
{
Handle textH;
UPtr begin, end; /* beginning and end of all text */
UPtr sBegin, sEnd; /* beginning and end of selected bit */
UPtr lBegin, lEnd; /* beginning and end of current line */
Str255 line;
long selStart, selEnd;
Byte state;
Boolean found = false;
FSSpec spec;
Boolean colorThem = 0!=(what&attColor);
Boolean selectThem = 0!=(what&attSelect);
Boolean openThem = 0!=(what&attOpen);
Boolean finderSelect = 0!=(what&attFinder);
Boolean printThem = 0!=(what&attPrint);
if (!PeteIsValid(pte) && win) pte = win->pte;
if (!PeteIsValid(pte)) return(False);
if (PeteIsValid(pte) && !win) win = (*PeteExtra(pte))->win;
if (PeteGetTextAndSelection(pte,&textH,&selStart,&selEnd)) return(False);
if (!textH || !GetHandleSize(textH)) return(False);
state = HGetState(textH);
/*
* set initial values
*/
begin = LDRef(textH);
end = begin + GetHandleSize(textH);
sBegin = begin + ((startWith<0)?selStart:startWith);
sEnd = begin + ((endWith<0)?selEnd:endWith);
sBegin = MAX(sBegin,begin);
if (sBegin>=end) goto done;
sEnd = MIN(end,sEnd);
if (sEnd<=begin) goto done;
/*
* expand "selection" to whole lines
*/
while (sBegin>begin && sBegin[-1]!='\015') sBegin--;
if (selStart!=selEnd && sEnd[-1]=='\015') sEnd--;
else while (sEnd<end && sEnd[0]!='\015') sEnd++;
/*
* examine each line
*/
for (lBegin=sBegin;lBegin<sEnd;lBegin=lEnd+1)
{
for (lEnd=lBegin;lEnd<sEnd && lEnd[0]!='\015';lEnd++);
MakePStr(line,lBegin,lEnd-lBegin);
if (!PeteIsExcerptAt(pte,lBegin-begin+1) && !AttLine2Spec(line,&spec,openThem))
{
found = True;
if (colorThem)
{
#ifdef ATT_ICONS
MyWindowPtr pteWin = (*PeteExtra(pte))->win;
WindowPtr pteWinWP = GetMyWindowWindowPtr (pteWin);
TOCHandle tocH;
if (GetWindowKind(pteWinWP)==MESS_WIN ||
(GetWindowKind(pteWinWP)==MBOX_WIN &&
// Don't display attachment icons in search windows unless it's in the preview pane
(!IsSearchWindow(pteWinWP) || ((tocH=(TOCHandle)GetMyWindowPrivateData(pteWin)) && (*tocH)->previewPTE==pte))))
PeteFileGraphicRange(pte,lBegin-begin,lEnd-begin,&spec,fgAttachment+fgDontCopyToClip+(PrefIsSet(PREF_NO_INLINE)?0:fgDisplayInline));
else
#endif
URLStyle(pte,lBegin-begin,lEnd-begin,False);
}
if (selectThem)
{
PeteSelect(nil,pte,lBegin-begin,lEnd-begin);
PeteSetDirty(pte);
}
if (openThem||printThem) OpenAttLine(pte,line,finderSelect,printThem);
if (aStart) *aStart = lBegin-begin;
if (aEnd) *aEnd = lEnd-begin;
}
}
done:
HSetState(textH,state);
return(found);
}
/************************************************************************
* IsAttLine - is a line an attachment line?
************************************************************************/
Boolean IsAttLine(PStr line,Boolean wantToOpen)
{
return (!AttLine2Spec(line,nil,wantToOpen));
}
/************************************************************************
* OpenAttLine - open an attachment described by a line
************************************************************************/
OSErr OpenAttLine(PETEHandle pte,PStr line,Boolean finderSelect,Boolean printIt)
{
short err = noErr;
FSSpec spec;
if (!(err=AttLine2Spec(line,&spec,True)))
{
#ifdef IMAP
// If this is an IMAP attachment, download it.
if (IsIMAPAttachmentStub(&spec))
{
// fetch the attachment, wait for it to be downloaded.
// spec will point to the downloaded attachment.
err = FetchIMAPAttachment(pte,&spec,true);
}
#endif
if (err==noErr) err = OpenOtherDoc(&spec,finderSelect,printIt,nil);
}
return(err);
}
/************************************************************************
* AttLine2Spec - get an FSSpec from an attachment line
* Heuristic
* - must end in 8 hex digits in []'s
* - must have at least two colons
* - text between first two colons must be volume name
************************************************************************/
OSErr AttLine2Spec(PStr line,FSSpecPtr spec,Boolean wantToOpen)
{
Str31 colostomy; /* bad joke, I know */
Str63 fName;
PStr colon1, colon2;
UPtr spot;
long fid=0;
short dig=8;
short err;
Boolean isFolder = nil!=PFindSub("\p (fldr/macs) (",line); //crude check for our folder creator
TrimWhite(line);
if (!IsWordChar[line[1]]) return fnfErr; // don't do quoted attachment lines
/*
* pick out the fid
*/
if (line[*line] != ']' && line[*line]!=')') return(fnfErr);
if (*line<10 || line[*line-9]!='[' && line[*line-9]!='(') return(fnfErr);
for (colon1=line+*line-8;dig--;colon1++)
if ('0'<=*colon1 && *colon1<='9')
fid = (fid<<4) | (*colon1-'0');
else if ('a'<=*colon1 && *colon1<='f')
fid = (fid<<4) | (10+*colon1-'a');
else if ('A'<=*colon1 && *colon1<='F')
fid = (fid<<4) | (10+*colon1-'A');
else return(fnfErr);
/*
* pick out the volume name
*/
colon1 = strchr(line+1,':'); if (!colon1) return(fnfErr);
colon2 = strchr(colon1+2,':'); if (!colon2) return(fnfErr);
if (spec)
{
MakePStr(colostomy,colon1+2,colon2-colon1-1);
MakePStr(fName,colon2+1,*line-(colon2-line)-23);
if (*fName<1 || *fName>31) err = fnfErr;
else
{
if (isFolder)
{
spec->vRefNum = GetMyVR(colostomy);
spec->parID = fid;
err = ParentSpec(spec,spec);
if (!err) err = GetDirName(nil,spec->vRefNum,fid,spec->name);
}
else
err = FSResolveFID(GetMyVR(colostomy),fid,spec);
if (err || !(spot=PPtrFindSub(fName,spec->name+1,*spec->name)) || spot!=spec->name+1)
{
#ifdef IMAP
//
// The names of IMAP attachments could get macified once downloaded.
// if the name the fileID resolved to is a Mac2OtherName()ed fName, then call it a match.
//
Str31 otherName;
// check only if FSResolveFID succeeded.
if (err == noErr)
Mac2OtherName(otherName, spec->name);
else
otherName[0] = 0;
// If fName and the Mac2OtherName match, we've found the file.
if ((otherName[0]==0) || !(spot=PPtrFindSub(fName,otherName+1,*otherName)) || spot!=otherName+1)
{
// otherwise, call it a match only if a file with the same name exists in the attachments folder.
#endif
GetAttFolderSpec(spec);
PCopy(spec->name,fName);
err = FSpExists(spec);
if (err && IsIMAPPers(CurPers))
if (!(err = GetIMAPAttachFolder(spec)))
{
PCopy(spec->name,fName);
err = FSpExists(spec);
}
// the increasing prevalence of long filenames means we increasingly
// cannot find attachments after a disk move. So, if this is a mangled
// name, look for the non-hex part as a prefix of a filename in the attachments folder
if (err && PrefIsSet(PREF_PROMISCUOUS_REATTACH))
{
Str31 stubName;
Str31 stubExtension;
// split into fershlugginer extension
SplitPerfectlyGoodFilenameIntoNameAndQuoteExtensionUnquote(fName,stubName,stubExtension,31);
if (!LopPoundHexDigits(stubName))
{
// Ok, now we have determined that the filename is of the form:
// stubName # hex-digits stubExtension
CInfoPBRec hfi;
Str31 foundFileName;
Str31 possibleFileName;
Boolean lastOneMatched = false;
Zero(hfi);
hfi.hFileInfo.ioNamePtr = possibleFileName;
while (!DirIterate(spec->vRefNum,spec->parID,&hfi))
{
Str31 possibleStub, possibleExtension;
SplitPerfectlyGoodFilenameIntoNameAndQuoteExtensionUnquote(possibleFileName,possibleStub,possibleExtension,31);
if (!(err = LopPoundHexDigits(possibleStub))) // a shortened filename
if (StringSame(possibleExtension,stubExtension))
if (!striscmp(possibleStub+1,stubName+1) && *possibleStub > 10)
{
// we have a match!
if (lastOneMatched)
{
// Sadness. We match more than one file.
err = dupFNErr;
break;
}
else
{
PCopy(foundFileName,possibleFileName);
lastOneMatched = true;
continue;
}
}
// we only get here if the current possible file does NOT match.
// if that's so, and the *last* one matched, then there is one and only
// one match, and we shout Bingo!, losing our dentures in the process
if (lastOneMatched)
{
PCopy(spec->name,foundFileName);
err = noErr; // hurray!
break;
}
}
}
}
}
#ifdef IMAP
}
#endif
}
if (wantToOpen && err) WarnUser(ATTACH_GONE,err);
return(err);
}
else return(colon2-colon1>1 && colon2-colon1<33 ? noErr : fnfErr);
}
/************************************************************************
* LopPoundHexDigits - strip the # and hex digits from a shortened filename
* returns fnfErr if no # or followed by non-hex digits
* returns dupFNErr if remaining filename is very short.
* null-terminates the string for convenience' sake
************************************************************************/
OSErr LopPoundHexDigits(PStr fileName)
{
Str31 hexDigits;
PStr poundSign = PIndex(fileName,'#');
short i;
if (!poundSign) return fnfErr;
MakePStr(hexDigits,poundSign+1,*fileName-(poundSign-fileName+2));
if (poundSign-fileName < 10) return dupFNErr;
for (i=1;i<*hexDigits;i++)
if (!IsHexDig(hexDigits[i]))
return fnfErr;
*fileName = poundSign-fileName-1;
PTerminate(fileName);
return noErr;
}
/************************************************************************
* RelLine2Spec - get an FSSpec from a "related" line
* - begin with "related:"
* - must have at least two colons
* - text between first two colons must be volume name
************************************************************************/
OSErr RelLine2Spec(PStr line,FSSpecPtr spec,uLong *cid, uLong *relURL, uLong *absURL)
{
Str255 token;
Str31 name;
UPtr spot = line+1;
Byte colon[2];
short vRef;
uLong fid;
OSErr err;
colon[0] = ':';
colon[1] = 0;
// related
if (!PToken(line,token,&spot,colon)) return(fnfErr);
if (!EqualStrRes(token,MIME_RELATED)) return(fnfErr);
// space
if (!PToken(line,token,&spot,colon)) return(fnfErr);
// volume name
if (!PToken(line,token,&spot,colon)) return(fnfErr);
vRef = GetMyVR(token);
if (vRef==REAL_BIG) return(fnfErr);
// filename
if (!PToken(line,token,&spot,colon)) return(fnfErr);
PSCopy(name,token);
FixURLString(name);
// fid
if (!PToken(line,token,&spot,colon)) return(fnfErr);
if (*token!=8) return(fnfErr);
Hex2Bytes(token+1,8,(void*)&fid);
// cid
if (!PToken(line,token,&spot,colon)) return(fnfErr);
if (*token!=8) return(fnfErr);
if (cid) Hex2Bytes(token+1,8,(void*)cid);
// rel
if (!PToken(line,token,&spot,colon)) return(fnfErr);
if (*token!=8) return(fnfErr);
if (relURL) Hex2Bytes(token+1,8,(void*)relURL);
// abs
if (!PToken(line,token,&spot,colon)) return(fnfErr);
if (*token!=8) return(fnfErr);
if (absURL) Hex2Bytes(token+1,8,(void*)absURL);
if (spec)
{
err = FSResolveFID(vRef,fid,spec);
if (err)
{
SubFolderSpec(PARTS_FOLDER,spec);
PSCopy(spec->name,name);
err = FSpExists(spec);
if (err==fnfErr)
{
FixURLString(name);
if (*name!=*spec->name)
err = FSpExists(spec);
}
}
return(err);
}
else return(noErr);
}
#endif
#pragma segment Balloon
/************************************************************************
* MessHelp - help for the message window
************************************************************************/
void MessHelp(MyWindowPtr win,Point mouse)
{
Rect subRect,bodRect,priorRect,r;
MessHandle messH = Win2MessH(win);
Rect blahRect;
Rect pencilRect;
Rect fixedRect;
PETEDocInfo info;
ControlHandle cntl,ctlGetGraphics;
PETEGetDocInfo(PETE,TheBody,&info);
bodRect = info.docRect;
PETEGetDocInfo(PETE,(*messH)->subPTE,&info);
subRect = info.docRect;
if (PtInRect(mouse,&bodRect))
MyBalloon(&bodRect,90,0,MESS_HELP,0,nil);
else if (win->topMargin)
{
GetPriorityRect(win,&priorRect);
GetBlahRect(win,1,&blahRect);
GetBlahRect(win,0,&pencilRect);
if (!FontIsFixed) GetBlahRect(win,2,&fixedRect);
if (PtInRect(mouse,&subRect))
MyBalloon(&subRect,90,0,SUB_EDIT_HELP,0,nil);
else if (!FontIsFixed && PtInRect(mouse,&fixedRect) &&
(cntl=FindControlByRefCon(win,mcFixed)))
MyBalloon(&fixedRect,90,0,
GetControlValue(cntl)?MESS_FIXED_HELP:NO_MESS_FIXED_HELP,
0,nil);
else if (PtInRect(mouse,&pencilRect))
MyBalloon(&pencilRect,90,0,
MessOptIsSet(Win2MessH(win),OPT_WRITE)?MESS_WRITE_HELP:NO_MESS_WRITE_HELP,
0,nil);
else if (PtInRect(mouse,&blahRect))
MyBalloon(&blahRect,90,0,
MessFlagIsSet(Win2MessH(win),FLAG_SHOW_ALL)?SHOW_ALL_HELP:NO_SHOW_ALL_HELP,
0,nil);
else if (PtInRect(mouse,&priorRect))
PriorMenuHelp(win,&priorRect);
else if ((ctlGetGraphics = FindControlByRefCon(win,mcGetGraphics)) &&
IsControlVisible(ctlGetGraphics) &&
PtInControl(mouse,ctlGetGraphics))
{
Rect getGraphicsRect;
GetControlBounds(ctlGetGraphics,&getGraphicsRect);
MyBalloon(&getGraphicsRect,90,0,
IsControlActive(ctlGetGraphics)?GET_GRAPHICS_HELP:NO_GET_GRAPHICS_HELP,
0,nil);
}
#ifdef TWO
else
{
GetServerRect(win,3,&r);
if (PtInRect(mouse,&r)) MyBalloon(&r,90,0,MESS_DRAG_HELP,0,nil);
else
{
r = win->contR;
r.bottom = win->topMargin;
r.top = GetRLong(COMP_TOP_MARGIN);
if (r.bottom>r.top && PtInRect(mouse,&r) && MessOptIsSet(messH,OPT_RECEIPT))
MyBalloon(&r,90,0,MESS_NOTIFY_HELP,0,nil);
else if ((*messH)->hasDelIcon)
{
GetServerRect(win,1,&r);
if (PtInRect(mouse,&r))
{
if ((*messH)->hasFetchIcon)
MyBalloon(&r,90,0,MESS_FETCH_HELP+(IdIsOnPOPD(PERS_POPD_TYPE(MESS_TO_PPERS(messH)),FETCH_ID,SumOf(messH)->uidHash)?0:1),0,nil);
}
else
{
GetServerRect(win,2,&r);
if (PtInRect(mouse,&r))
MyBalloon(&r,90,0,MESS_DELETE_HELP+(IdIsOnPOPD(PERS_POPD_TYPE(MESS_TO_PPERS(messH)),DELETE_ID,SumOf(messH)->uidHash)?0:1),0,nil);
else
{
GetServerRect(win,0,&r);
if (PtInRect(mouse,&r))
MyBalloon(&r,90,0,MESS_SERVER_HELP,0,nil);
}
}
}
}
}
#endif
}
}
/************************************************************************
* PriorMenuHelp - help for the priority menu
************************************************************************/
void PriorMenuHelp(MyWindowPtr win,Rect *priorRect)
{
Str255 s1,s2;
short p = Prior2Display((SumOf(Win2MessH(win)))->priority);
if (!HMIsBalloon())
{
GetRString(s1,PRIOR_MENU_HELP);
GetRString(s2,PRIOR_STRN+5+p);
PCat(s1,s2);
MyBalloon(priorRect,90,0,0,0,s1);
}
}
#pragma segment MessWin
/**********************************************************************
* SaveMess - save a message into its own mailbox
**********************************************************************/
Boolean SaveMess(MyWindowPtr win)
{
MessHandle messH = Win2MessH(win);
MSumPtr oldSum, newSum;
TOCHandle tocH = (*messH)->tocH;
long fromLen;
Handle text=MessText(messH);
HeadSpec hSpec;
Accumulator enriched;
OSErr err = noErr;
Boolean richSave = False;
Str255 title;
Boolean blahBlah = MessFlagIsSet(messH,FLAG_SHOW_ALL);
/*
* rich text?
*/
if (!blahBlah)
{
SetMessRich(messH);
Zero(enriched);
if (MessIsRich(messH))
{
if (!(err=AccuInit(&enriched)))
{
CompHeadFind(messH,0,&hSpec);
if (!(*messH)->extras.offset || !(err=AccuAddHandle(&enriched,(*messH)->extras.data)))
if (!(err=AccuAddFromHandle(&enriched,text,0,hSpec.value)))
{
if (MessOptIsSet(messH,OPT_HTML))
{
if (!(err=HTMLPreamble(&enriched,PCopy(title,SumOf(messH)->subj),0,True)))
{
NumToString(SumOf(messH)->msgIdHash,title);
if (!(err=BuildHTML(&enriched,TheBody,nil,GetHandleSize(text),hSpec.value,nil,nil,1,title,nil,nil)))
err=HTMLPostamble(&enriched,True);
}
}
else
{
err=BuildEnriched(&enriched,TheBody,nil,PETEGetTextLen(PETE,TheBody),hSpec.value,nil,True);
}
if (!err)
{
AccuTrim(&enriched);
err = SaveTextAsMessage(nil,enriched.data,(*messH)->tocH,&fromLen);
ZapHandle(enriched.data);
if (err) return(False);
richSave = True;
}
}
}
}
}
if (err)
{
WarnUser(CANT_SAVE_RICH,err);
ZapHandle(enriched.data);
ClearMessFlag(messH,FLAG_RICH);
ClearMessOpt(messH,OPT_HTML);
}
/*
* save plain text to the end of the mailbox
*/
if (!richSave)
if (SaveTextAsMessage(!blahBlah && (*messH)->extras.offset ? (*messH)->extras.data:nil,text,(*messH)->tocH,&fromLen)) return(False);
/*
* copy the offset parameters
*/
oldSum = &(*tocH)->sums[(*messH)->sumNum];
newSum = &(*tocH)->sums[(*tocH)->count-1];
(*tocH)->usedK -= oldSum->length/1024; /* we're going to waste the old one */
(*tocH)->updateBoxSizes = true;
oldSum->offset = newSum->offset;
oldSum->length = newSum->length;
oldSum->bodyOffset = newSum->bodyOffset;
if (newSum->seconds && !(oldSum->flags&FLAG_OUT))
{
oldSum->seconds = newSum->seconds;
oldSum->origZone = newSum->origZone;
}
// outgoing IMAP messages have the recipient stored in the From: field of the summary.
// Save it.
if ((*tocH)->imapTOC && (oldSum->opts&OPT_IMAP_SENT))
{
if (*oldSum->from) PCopy(newSum->from,oldSum->from);
}
else
{
if (*newSum->from) PCopy(oldSum->from,newSum->from);
}
InvalSum(tocH,(*messH)->sumNum);
// retitle window
if ((*messH)->win)
{
MakeMessTitle(title,tocH,(*messH)->sumNum,true);
SetWTitle_(GetMyWindowWindowPtr((*messH)->win),title);
}
/*
* shrink the .toc
*/
(*tocH)->count--;
SetHandleBig_(tocH,GetHandleSize_(tocH)-sizeof(MSumType));
/*
* reset this to the right stuff
*/
(*messH)->weeded = fromLen + (blahBlah ? 0 : (*messH)->extras.offset);
/*
* rescan for URL's, quotes
*/
PeteSetURLRescan(TheBody,0);
/*
* not dirty any more
*/
PeteCleanList(win->pteList);
win->isDirty = False;
/*
* cache is toast
*/
ZapHandle(SumOf(messH)->cache);
SetMessOpt(messH,OPT_EDITED);
ZapHandle((*messH)->etlFiles); // we've recorded them permanently now
// let the preview pane know
if ((*tocH)->previewID==SumOf(messH)->serialNum) (*tocH)->previewID = 0;
return(True);
}
/**********************************************************************
* ShowMessageSeparator - show the message separator
**********************************************************************/
void ShowMessageSeparator(PETEHandle pte,Boolean center)
{
long body = BodyOffset(PeteText(pte));
PeteSelect(nil,pte,body,body);
PeteCalcOn(pte);
if (center)
{
PeteScroll(pte,0,0);
PeteScroll(pte,0,pseCenterSelection);
}
else
{
PeteScroll(pte,0,0x7fff);
PeteScroll(pte,0,pseSelection);
}
}
/**********************************************************************
* MessMenu - handle menu choices for a message window
**********************************************************************/
Boolean MessMenu(MyWindowPtr win,int menu,int item,short modifiers)
{
MessHandle messH = (MessHandle)GetMyWindowPrivateData(win);
TOCHandle tocH = (*messH)->tocH;
int sumNum = (*messH)->sumNum;
Boolean result = False;
short tableId;
Boolean turbo = False;
uLong ezOpenSerialNum;
TextAddrHandle addr=nil;
switch (menu)
{
case FILE_MENU:
switch(item)
{
case FILE_PRINT_ITEM:
case FILE_PRINT_ONE_ITEM:
MessFocus(messH,TheBody);
if ((modifiers&shiftKey) && AttIsSelected(win,win->pte,-1,-1,attOpen+attPrint,nil,nil))
;// done
else
PrintOneMessage((*messH)->win,(modifiers&shiftKey)!=0,item==FILE_PRINT_ONE_ITEM);
result = True;
break;
case FILE_SAVE_ITEM:
if (win->isDirty)
{
if ((*messH)->subPTE && PeteIsDirty((*messH)->subPTE)) MessSaveSub(messH);
if ((*messH)->subPTE && PeteIsDirty((*messH)->bodyPTE)) SaveMess(win);
PeteCleanList(win->pteList);
win->isDirty = False;
}
result = True;
break;
case FILE_BROWSE_ITEM:
ExportHTML(messH);
result = True;
break;
case FILE_SAVE_AS_ITEM:
SaveMessageAs(messH);
result = True;
break;
}
break;
case SERVER_HIER_MENU:
#ifdef IMAP
ServerMenuChoice((*messH)->tocH,(*messH)->sumNum,item, (modifiers&shiftKey)!=0);
#else
ServerMenuChoice((*messH)->tocH,(*messH)->sumNum,item);
#endif
result = True;
break;
case EDIT_MENU:
switch (item) {
#ifdef SPEECH_ENABLED
case EDIT_SPEAK_ITEM:
if (!(modifiers & shiftKey)) {
(void) SpeakMessage (nil, (*messH)->tocH, (*messH)->sumNum, speakSender | speakSubject | speakBody, false);
return (true);
}
break;
#endif
default:
return(False);
break;
}
break;
case MESSAGE_MENU:
MessFocus(messH,TheBody);
switch (item)
{
case MESSAGE_REPLY_ITEM:
{
Boolean all, quote, self;
ReplyDefaults(modifiers,&all,&self,&quote);
DoReplyMessage(win,all,self,quote,True,0,True,True,True);
}
result = True;
break;
case MESSAGE_REDISTRIBUTE_ITEM:
DoRedistributeMessage(win,0,PrefIsSetOrNot(PREF_TURBO_REDIRECT,modifiers,optionKey),!(modifiers&shiftKey),True);
result = True;
break;
case MESSAGE_FORWARD_ITEM:
DoForwardMessage(win,0,True);
result = True;
break;
case MESSAGE_SALVAGE_ITEM:
DoSalvageMessage(win,False);
result = True;
break;
case MESSAGE_JUNK_ITEM:
case MESSAGE_NOTJUNK_ITEM:
Junk(tocH,sumNum,item==MESSAGE_JUNK_ITEM,true);
break;
case MESSAGE_DELETE_ITEM:
EzOpen((*messH)->openedFromTocH,-1,(*messH)->openedFromSerialNum,modifiers,True,True);
NoSaves = !MessOptIsSet(Win2MessH(win),OPT_WRITE);
if (CloseMyWindow(GetMyWindowWindowPtr(win)))
{
#ifdef TWO
AddXfUndo(tocH,GetTrashTOC(),sumNum);
#endif
DeleteMessage(tocH,sumNum,(modifiers&(optionKey|shiftKey))==(optionKey|shiftKey));
}
NoSaves = False;
result = True;
break;
}
break;
case REPLY_WITH_HIER_MENU:
//Stationery - no support for this in Light
if (HasFeature (featureStationery)) {
Boolean all, quote, self;
ReplyDefaults(modifiers,&all,&self,&quote);
DoReplyMessage(win,all,self,quote,True,item,True,True,True);
}
result = True;
break;
case FORWARD_TO_HIER_MENU:
DoForwardMessage(win,(addr=MenuItem2Handle(menu,item)),True);
result = True;
break;
case REDIST_TO_HIER_MENU:
#ifdef TWO
turbo = PrefIsSetOrNot(PREF_TURBO_REDIRECT,modifiers,optionKey);
if (turbo) EzOpen(tocH,sumNum,0,modifiers,True,True);
#endif
DoRedistributeMessage(win,(addr=MenuItem2Handle(menu,item)),turbo,!(modifiers&shiftKey),True);
result = True;
ZapHandle(addr);
break;
case TABLE_HIER_MENU:
if (Menu2TableId(tocH,GetMHandle(TABLE_HIER_MENU),item,&tableId))
SetMessTable(tocH,sumNum,tableId);
result = True;
break;
case STATE_HIER_MENU:
SetState(tocH,sumNum,Item2Status(item));
result = True;
break;
case LABEL_HIER_MENU:
item = Menu2Label(item);
SetSumColor(tocH,sumNum,item);
result = True;
break;
case SPECIAL_MENU:
switch(AdjustSpecialMenuSelection(item))
{
case SPECIAL_MAKE_NICK_ITEM:
if (modifiers&shiftKey)
MakeNickFromSelection(win);
else
MakeMessNick(win,modifiers);
result = True;
break;
case SPECIAL_MAKEFILTER_ITEM:
DoMakeFilter(win);
break;
#ifdef TWO
case SPECIAL_FILTER_ITEM:
ezOpenSerialNum = (*messH)->ezOpenSerialNum;
FilterMessage(flkManual,tocH,sumNum);
if (FrontWindow_()!=GetMyWindowWindowPtr(win) && (*tocH)->count)
if (ezOpenSerialNum)
EzOpen(tocH,sumNum,ezOpenSerialNum,modifiers,False,False);
else
BoxSelectAfter((*tocH)->win,sumNum);
result = True;
break;
#endif
}
break;
case PRIOR_HIER_MENU:
SetPriority(tocH,sumNum,NewPrior(item,(*tocH)->sums[sumNum].priority));
result = True;
break;
case PERS_HIER_MENU:
//No Personalities menu in Light
if (HasFeature (featureMultiplePersonalities)) {
Str63 name;
SetPers(tocH,sumNum,FindPersByName(MyGetItem(GetMHandle(menu),item,name)),True);
return(True);
}
break;
#ifdef DEBUG
case DEBUG_MENU:
if(item == dbTestSpooler)
{
SpoolMessage(messH, nil, 0);
return(True);
}
break;
#endif
default:
if ((*messH)->openedFromTocH != (*messH)->tocH)
sumNum = FindSumBySerialNum((*messH)->openedFromTocH,(*messH)->openedFromSerialNum);
result = TransferMenuChoice(menu,item,(*messH)->openedFromTocH,sumNum,modifiers,False);
break;
}
ZapHandle(addr);
return(result);
}
/************************************************************************
* Fcc - add a mailbox to
************************************************************************/
void Fcc(MessHandle messH,FSSpecPtr box)
{
Str255 scratch;
HeadSpec hs;
long start;
Str255 path;
//Folder Carbon Copy No FCC in Light
if (!HasFeature (featureFcc))
return;
UseFeature (featureFcc);
if (Box2Path(box,path)) PCopy(path,box->name);
*scratch = 0;
PCatC(scratch,'"');
PCatR(scratch,FCC_PREFIX);
PCat(scratch,path);
PCatC(scratch,'"');
SetPort(GetMyWindowCGrafPtr((*messH)->win));
if (CompHeadFind(messH,BCC_HEAD,&hs))
{
PetePrepareUndo(TheBody,peCantUndo,hs.stop,hs.stop,&start,nil);
InsertCommaIfNeedBe(TheBody,&hs);
CompHeadAppendStr(TheBody,&hs,scratch);
CompHeadFind(messH,BCC_HEAD,&hs);
PeteSelect(nil,TheBody,hs.stop,hs.stop);
PeteFinishUndo(TheBody,peUndoPaste,start,hs.stop);
ClearMessFlag(messH,FLAG_KEEP_COPY);
CompIBarUpdate(messH);
}
}
/**********************************************************************
* EzOpenFind - find next candidate for EzOpen. If none, return -1
**********************************************************************/
short EzOpenFind(TOCHandle tocH, short origSum)
{
short newSum;
long ez = GetPrefLong(PREF_NO_EZ_OPEN);
if (origSum<(*tocH)->count-1)
{
if (ez==1) return(origSum+1); // say no more
if ((*tocH)->sums[origSum+1].state==UNREAD)
{
if (ez==3 || ez==2) return(origSum+1); // say no more
if (ez==4)
{
Str63 s1, s2;
PSCopy(s1,(*tocH)->sums[origSum].subj);
PSCopy(s2,(*tocH)->sums[origSum+1].subj);
if (!SubjCompare(s1,s2)) return origSum+1;
}
}
}
if (ez==2)
for (newSum=origSum+2;newSum<(*tocH)->count;newSum++)
if ((*tocH)->sums[newSum].state==UNREAD) return(newSum);
return(-1);
}
/************************************************************************
* EzOpen - easy open, if things are right
************************************************************************/
void EzOpen(TOCHandle tocH, short sumNum,uLong serialNum,long modifiers,Boolean hideFront, Boolean willDelete)
{
WindowPtr oldFrontWP = FrontWindow_();
short newSumNum;
Boolean oldVis;
short ez;
Boolean preview = false;
if ((*tocH)->win)
{
if (sumNum < 0)
{
sumNum = FindSumBySerialNum(tocH,serialNum);
if (sumNum < 0)
return; // unable to find message with this serial number
}
/*
* if the frontmost window is our cue, grab its hash value
*/
if (hideFront)
{
TOCHandle realTOC;
short realSum;
realTOC = GetRealTOC(tocH,sumNum,&realSum);
if ((*realTOC)->sums[realSum].messH)
serialNum = (*(*realTOC)->sums[realSum].messH)->ezOpenSerialNum;
else if ((*tocH)->previewPTE && (*tocH)->previewID)
{
preview = true;
serialNum = (*tocH)->ezOpenSerialNum;
}
}
else
sumNum=FindSumBySerialNum(tocH,serialNum);
/*
* does message exist?
*/
if (serialNum && (newSumNum=FindSumBySerialNum(tocH,serialNum))>=0 &&
(*tocH)->sums[newSumNum].state==UNREAD)
/* we have our man */;
else
{
/*
* if we're not hiding the front window, that means it was deleted before
* the easy open; back up one
*/
if (!hideFront) newSumNum = EzOpenFind(tocH,sumNum-1);
else newSumNum = EzOpenFind(tocH,sumNum);
}
/*
* did we find one to easy open?
*/
if (newSumNum>=0)
{
ez = GetPrefLong(PREF_NO_EZ_OPEN);
if (modifiers & shiftKey) ez = 0;
SelectBoxRange(tocH,newSumNum,newSumNum,False,-1,-1);
if (ez)
{
if (preview) Preview(tocH,newSumNum);
else
{
MyWindowPtr oldFront = GetWindowMyWindowPtr (oldFrontWP);
if (hideFront && oldFront)
{
oldVis = oldFront->hideme;
oldFront->hideme = True;
UglyHackFrontWindow = oldFrontWP;
}
BoxOpen((*tocH)->win);
if (hideFront && oldFront) oldFront->hideme = oldVis;
UglyHackFrontWindow = nil;
}
}
BoxCenterSelection((*tocH)->win);
}
else
{
if (willDelete) newSumNum = sumNum==(*tocH)->count-1 ? sumNum-1 : sumNum+1;
else newSumNum = sumNum;
newSumNum = MIN(newSumNum,(*tocH)->count-1);
newSumNum = MAX(newSumNum,0);
SelectBoxRange(tocH,newSumNum,newSumNum,False,-1,-1);
}
}
}
/************************************************************************
* SaveMessageAs - save a message in text only form
************************************************************************/
void SaveMessageAs(MessHandle messH)
{
long creator;
short refN;
short err;
Str31 name;
FSSpec spec;
Str255 scratch;
ModalFilterYDUPP filter=nil;
NicknameWatcherFocusChange((**messH).win->pte); /* MJN */
/*
* tickle stdfile
*/
creator = DefaultCreator();
MakeMessFileName((*messH)->tocH,(*messH)->sumNum,spec.name);
#ifdef TWO
//Stationery - prevent the user from saving a file as stationery
Stationery = (HasFeature (featureStationery) && (*(*messH)->tocH)->which==OUT && !DateWarning(false)) ? False : 2; /* 2 is our signal to the filter to hide the item */
#endif
if (err=SFPutOpen(&spec,creator,'TEXT',&refN,nil,filter,SAVEAS_DLOG,nil,nil,nil))
return;
/*
* do it
*/
if (Stationery)
{
// Need to save with different msg ID hash
TOCHandle tocH = (*messH)->tocH;
short sumNum = (*messH)->sumNum;
long saveHash = (*tocH)->sums[sumNum].msgIdHash;
NewMessageId(scratch);
SetHash(tocH,sumNum,MIDHash(scratch+1,*scratch));
err = SaveAsToOpenFile(refN,messH);
SetHash(tocH,sumNum,saveHash);
}
else
err = SaveAsToOpenFile(refN,messH);
/*
* close
*/
(void) MyFSClose(refN);
/*
* report error
*/
if (err)
{
FileSystemError(COULDNT_SAVEAS,name,err);
FSpDelete(&spec);
}
}
/************************************************************************
* SaveAsToOpenFile - continue the message saving process
************************************************************************/
short SaveAsToOpenFile(short refN,MessHandle messH)
{
OSErr err;
unsigned long saveOpts = SumOf(messH)->opts;
err = SaveAsToOpenFileLo(refN,messH);
if (Stationery && !err && ((saveOpts&OPT_HAS_SPOOL) != (SumOf(messH)->opts&OPT_HAS_SPOOL)))
{
// The first save didn't save the OPT_HAS_SPOOL flag properly. Save again.
// Shameful, but this should happen only the first time a stationery
// is saved with graphics.
SetFPos(refN,fsFromStart,0);
err = SaveAsToOpenFileLo(refN,messH);
}
return err;
}
/************************************************************************
* SaveAsToOpenFileLo - continue the message saving process
************************************************************************/
static short SaveAsToOpenFileLo(short refN,MessHandle messH)
{
long bytes;
short err=0;
UPtr where;
UHandle text;
Str63 scratch;
Boolean para = PrefIsSet(PREF_PARAGRAPHS);
Boolean exclHead = PrefIsSet(PREF_EXCLUDE_HEADERS) || (SumOf(messH)->flags&FLAG_SUBSEQUENT);
Boolean isOut = (*(*messH)->tocH)->which==OUT;
HeadSpec hs;
Accumulator enriched;
StackHandle stack = nil;
Zero(enriched);
SetMessRich(messH);
PETEGetRawText(PETE,TheBody,&text);
CompHeadFind(messH,0,&hs);
#ifdef TWO
//Stationery - prevent the user from saving a file as stationery
if (HasFeature (featureStationery) && Stationery==True)
{
if (err = SaveStationeryStuff(refN,messH)) return(err);
para = exclHead = False;
}
#endif
/*
* build and save date header
*/
if (!exclHead && isOut && SumOf(messH)->seconds)
{
BuildDateHeader(scratch,SumOf(messH)->seconds);
PCatC(scratch,'\015');
FSWriteP(refN,scratch);
}
where = LDRef(text);
bytes = GetHandleSize(text);
if (exclHead)
{
where = LDRef(text)+hs.value;
bytes = hs.stop-hs.value;
while (bytes > 1 && *where == '\015') {where++;bytes--;}
while (bytes>1&&where[bytes-1]==where[bytes-2]&&where[bytes-1]=='\015')
bytes--;
}
//Stationery - prevent the user from saving a file as stationery
if (HasFeature (featureStationery) && Stationery)
{
if (MessIsRich(messH) && !(err=AccuInit(&enriched)))
{
AccuAddPtr(&enriched,where,hs.start);
AccuAddChar(&enriched,'\015');
if (MessOptIsSet(messH,OPT_HTML))
{
if (!(err=StackInit(sizeof(FSSpec),&stack)))
if (!(err=HTMLPreamble(&enriched,PCopy(scratch,SumOf(messH)->subj),0,True)))
if (!(err=BuildHTML(&enriched,TheBody,nil,PETEGetTextLen(PETE,TheBody),hs.value,nil,nil,1,CompGetMID(messH,scratch),nil,nil)))
err=HTMLPostamble(&enriched,True);
}
else
err = BuildEnriched(&enriched,TheBody,nil,PETEGetTextLen(PETE,TheBody),hs.value,nil,True);
ZapHandle(stack);
if (!err)
{
AccuTrim(&enriched);
text = enriched.data;
where = LDRef(enriched.data);
bytes = enriched.offset;
}
}
}
if (!err && !para)
{
err = AWrite(refN,&bytes,where);
EnsureNewline(refN);
UL(text);
}
else
{
err = UnwrapSave(where,bytes,0,refN);
UL(text);
}
if (!err) BeenThereDoneThat((*messH)->tocH,(*messH)->sumNum);
AccuZap(enriched);
return(err);
}
/************************************************************************
* UnwrapSave - save and unwrap a message
************************************************************************/
#define flushBChars() do { \
if (bytes=bSpot-buffer) \
{ \
err = refN ? AWrite(refN,&bytes,buffer) : \
(WrapHandle ? PtrPlusHand_(buffer,WrapHandle,bytes) : noErr);\
if (err) goto done; \
bSpot = buffer; \
} \
} while (0)
#define putBChar(theC) do { \
*bSpot++ = theC; \
if (bSpot==bEnd) flushBChars(); \
} while (0)
#define UnwrapSpaceRuns ((unwrapPref&1)==0)
#define UnwrapCenteredBreak ((unwrapPref&2)==0)
#define UnwrapIndent ((unwrapPref&4)==0)
#define UnwrapQuote ((unwrapPref&8)==0)
#define UnwrapShortLine ((unwrapPref&16)==0)
#define UnwrapBlankLine ((unwrapPref&32)==0)
int UnwrapSave(UPtr text, long length, long offset, short refN)
{
struct LineInfo
{
int length;
int indent;
int quote;
int needReturn;
};
struct LineInfo lines[2];
struct LineInfo *this, *last;
int flip;
int c;
UPtr tSpot;
int begin;
int spaces;
UPtr buffer = NuPtr(BUFFER_SIZE);
UPtr bSpot, bEnd;
int err=0;
long bytes;
Str31 s;
Byte quote;
Boolean quoteSpace;
short i;
uLong unwrapPref = GetPrefLong(PREF_UNWRAP_OPTIONS);
quote=GetRString(s,QUOTE_PREFIX)[1];
quoteSpace = s[*s]==' ';
if (!buffer) return(MemError());
bEnd = buffer+BUFFER_SIZE;
bSpot = buffer;
WriteZero(lines,sizeof(lines));
this = lines;
last = lines+1;
flip=this->length=this->indent=this->needReturn=last->length=last->indent=0;
last->needReturn=begin=1;
for (tSpot=text+offset;tSpot<text+length;tSpot++)
{
c = *tSpot;
if (c=='\015')
{
this->needReturn = this->needReturn ||
(UnwrapCenteredBreak && this->indent>20) ||
(UnwrapShortLine && this->length<40) ||
(UnwrapBlankLine && this->length==0);
if (this->needReturn)
{
if (this->length==0)
{
if (!last->needReturn) putBChar('\015');
for (i=0;i<this->quote;i++) putBChar(quote);
}
putBChar('\015');
}
else
putBChar(' ');
last = this;
flip = 1-flip;
this = lines + flip;
this->length = this->quote = this->indent = this->needReturn = 0;
begin = 1;
spaces = 0;
}
else if (c==' ')
{
if (begin) this->indent++;
else spaces++;
}
else if (begin && c==quote)
{
this->quote++;
}
else
{
if (!begin)
{
if (spaces>4 && (void*)SendTrans!=(void*)WrapSendTrans && UnwrapSpaceRuns)
{
putBChar('\t');
this->needReturn = 1;
}
else if (spaces)
{
putBChar(' ');
this->length++;
}
}
else if (((UnwrapIndent)&&this->indent>last->indent || UnwrapQuote&&this->quote!=last->quote) &&
!last->needReturn)
{
putBChar('\015');
for (i=0;i<this->quote;i++) putBChar(quote);
this->length += this->quote;
if (quoteSpace)
{
this->length++;
putBChar(' ');
}
}
else if (this->quote && last->needReturn)
{
for (i=0;i<this->quote;i++) putBChar(quote);
this->length += this->quote;
if (quoteSpace)
{
this->length++;
putBChar(' ');
}
}
begin = 0;
spaces = 0;
putBChar(c);
this->length++;
}
}
flushBChars();
done:
ZapPtr(buffer);
return(err);
}
/************************************************************************
* MessKey - handle a keydown in a message window
************************************************************************/
Boolean MessKey(MyWindowPtr win, EventRecord *event)
{
MessHandle messH = (MessHandle)GetMyWindowPrivateData(win);
TOCHandle tocH = (*messH)->tocH;
long uLetter = UnadornMessage(event)&charCodeMask;
Boolean bodyEdit = !win->ro && win->pte==TheBody;
Boolean shift = 0!=(event->modifiers & shiftKey);
if (leftArrowChar<=uLetter && uLetter<=downArrowChar &&
IsArrowSwitch(event->modifiers))
{
NextMess(tocH,messH,uLetter,event->modifiers,False);
return(True);
}
else if ((event->modifiers&cmdKey)!=0 && (uLetter==delChar||uLetter==deleteKey))
{
DoMenu2(GetMyWindowWindowPtr(win),MESSAGE_MENU,MESSAGE_DELETE_ITEM,event->modifiers);
return(true);
}
else if (!bodyEdit && (uLetter==tabChar || uLetter==enterChar))
{
MessFocus(messH,win->pte==(*messH)->subPTE ? TheBody : (*messH)->subPTE);
if (win->pte==(*messH)->subPTE) PeteSelectAll(win,win->pte);
}
else if (event->modifiers&cmdKey)
{
return(False);
}
else if (win->ro && uLetter==' ')
{
if (PeteScroll(TheBody,0,shift ? psePageUp : psePageDn) && !shift)
{
NextMess(tocH,messH,downArrowChar,0,True);
return(True);
}
}
else if (win->ro && DirtyKey(event->message))
AlertStr(READ_ONLY_ALRT, Stop, nil);
else if (!bodyEdit && !win->ro && uLetter==returnChar)
SysBeep(20L);
else
{
PeteEdit(win,win->pte,peeEvent,(void*)event);
}
PeteSetDirty(win->pte);
return(True);
}
/************************************************************************
* NextMess - skip to the next message
************************************************************************/
void NextMess(TOCHandle tocH,MessHandle messH,short whichWay,long modifiers,Boolean ezOpen)
{
WindowPtr messWinWP = GetMyWindowWindowPtr ((*messH)->win);
short next;
Boolean close,diffTOC;
short sumNum;
if (IsArrowSwitch(modifiers)) modifiers &= ~GetPrefLong(PREF_SWITCH_MODIFIERS);
close = !(modifiers&optionKey); /* should we close the current one? */
if (ezOpen && tocH==(*messH)->openedFromTocH)
{
EzOpen(tocH,(*messH)->sumNum,0,0,True,False);
CloseMyWindow(messWinWP);
return;
}
if ((*messH)->openedFromTocH && tocH!=(*messH)->openedFromTocH)
{
tocH = (*messH)->openedFromTocH;
if (!FindRealSummary(tocH, (*messH)->openedFromSerialNum, &sumNum))
return;
diffTOC = true;
}
else
{
sumNum = (*messH)->sumNum;
diffTOC = false;
}
switch (whichWay)
{
case upArrowChar:
case leftArrowChar:
next = sumNum-1;
break;
case downArrowChar:
case rightArrowChar:
next = sumNum+1;
break;
default:
return;
}
if (next!=sumNum)
{
if (close && (*messH)->win->isDirty) /* close before switch if dirty */
{
if (!CloseMyWindow(messWinWP)) return;
close = False;
}
if (next>=0 && next<(*tocH)->count)
{
if ((*tocH)->sums[next].messH)
{
WindowPtr tocMessWinWP = GetMyWindowWindowPtr ((*(MessHandle)(*tocH)->sums[next].messH)->win);
ShowMyWindow(tocMessWinWP);
UserSelectWindow(tocMessWinWP);
UpdateMyWindow(tocMessWinWP);
}
else
{
if (close) (*messH)->win->hideme = true;
(void) GetAMessage(tocH,next,nil,nil,True);
if (close) (*messH)->win->hideme = false;
if (diffTOC)
BeenThereDoneThat(tocH,next); // set status to READ in virtual mailbox
}
if ((*tocH)->sums[next].messH)
UpdateMyWindow(GetMyWindowWindowPtr((*(*tocH)->sums[next].messH)->win));
SelectBoxRange(tocH,next,next,False,-1,-1);
BoxCenterSelection((*tocH)->win);
}
}
if (close) CloseMyWindow(GetMyWindowWindowPtr((*messH)->win));
}
/**********************************************************************
*
**********************************************************************/
void SADL_Hilite(DialogPtr dgPtr)
{
short junk;
ControlHandle cntl;
Rect r;
GetDialogItem(dgPtr,SADL_EXCLUDE_HEADERS,&junk,(Handle*)&cntl,&r);
HiliteControl(cntl,Stationery==1?255:0);
GetDialogItem(dgPtr,SADL_PARAGRAPHS,&junk,(Handle*)&cntl,&r);
HiliteControl(cntl,Stationery==1?255:0);
GetDialogItem(dgPtr,SADL_STATIONERY_FOLDER,&junk,(Handle*)&cntl,&r);
HiliteControl(cntl,Stationery==1?0:255);
}
/**********************************************************************
* MessFind - find in the window
**********************************************************************/
Boolean MessFind(MyWindowPtr win,PStr what)
{
return FindInPTE(win,(*Win2MessH(win))->bodyPTE,what);
}
/************************************************************************
* MessProxy - handle a click in the proxy icon of a message window
************************************************************************/
void MessProxy(MyWindowPtr win,EventRecord *event)
{
Point pt = event->where;
MessHandle messH = Win2MessH(win);
PushGWorld();
SetPort_(GetMyWindowCGrafPtr(win));
GlobalToLocal(&pt);
DragXfer(pt,nil,messH);
PopGWorld();
}
/************************************************************************
* MessClick - handle a click in the message window
************************************************************************/
void MessClick(MyWindowPtr win,EventRecord *event)
{
Point pt = event->where;
PETEHandle pte=nil;
MessHandle messH = Win2MessH(win);
SetPort_(GetMyWindowCGrafPtr(win));
GlobalToLocal(&pt);
if (!win->isActive)
{
SelectWindow_(GetMyWindowWindowPtr(win));
return;
}
if (PtInPETE(pt,TheBody))
{
pte = TheBody;
}
else if (PtInPETE(pt,(*messH)->subPTE))
{
pte = (*messH)->subPTE;
}
#ifdef IMAP
// Don't allow subjects of undownloaded messages to be changed.
if (pte && (!(*((*messH)->tocH))->imapTOC || IMAPMessageDownloaded((*messH)->tocH, (*messH)->sumNum)))
#else
if (pte)
#endif
{
if (PeteEdit(win,pte,peeEvent,(void*)event)==tsmDocNotActiveErr)
{
MessFocus(messH,pte);
PeteEdit(win,pte,peeEvent,(void*)event);
}
}
else if (win->labelCntl && PtInControl(pt,win->labelCntl))
{
BoxLabelMenu((*messH)->tocH,(*messH)->sumNum,messH,pt);
}
else
{
EnableMenuItems(False);
SetMenuTexts(0,False);
HandleControl(pt,win);
}
}
/**********************************************************************
* MessButton - click on a button in the message
**********************************************************************/
void MessButton(MyWindowPtr win,ControlHandle button,long modifiers,short part)
{
WindowPtr winWP = GetMyWindowWindowPtr (win);
MessHandle messH = Win2MessH(win);
short value = GetControlValue(button);
PETEDocInfo info;
#ifndef USEFIXEDDEFAULTFONT
Str63 s;
#endif
short oldWidth, width, fixedWidth, fixedID, fixedSize, newWidth;
Rect rWin;
switch (GetControlReference(button))
{
case NOTIFY_CNTL:
if (!(modifiers&optionKey))
GenerateReceipt(messH,MDN_DISPLAYED,MDN_DISPLAYED_LOCAL,
MessOptIsSet(messH,OPT_AUTO_OPENED) ? MDN_AUTO_ACTION:MDN_MAN_ACTION,
MDN_MAN_SENT);
ClearMessOpt(messH,OPT_RECEIPT);
DisposeControl(button);
if (button=FindControlByRefCon(win,MDN_REQUEST)) DisposeControl(button);
if (button=FindControlByRefCon(win,MDN_REQUEST+1)) DisposeControl(button);
SetTopMargin(win,GetRLong(COMP_TOP_MARGIN));
MyWindowDidResize(win,nil);
break;
case PRIOR_HIER_MENU:
DoMenu(winWP,PRIOR_HIER_MENU<<16|GetBevelMenuValue(button),modifiers);
break;
case mcMesgErrors:
break;
case mcWrite:
MessMakeEditable(win,1-value);
break;
case mcBlahBlah:
PETEGetDocInfo(PETE,TheBody,&info);
if (info.dirty)
{
if (!PrefIsSet(PREF_EZ_SAVE))
{
if (!SaveMessHi(win,False)) return;
}
else if (!SaveMess(win)) return;
}
SetControlValue(button,1-value);
if (value) ClearMessFlag(messH,FLAG_SHOW_ALL);
else SetMessFlag(messH,FLAG_SHOW_ALL);
ReopenMessage(win);
break;
case mcFixed:
#ifdef USEFIXEDDEFAULTFONT
fixedSize = FixedSize;
fixedID = FixedID;
#else
// what size to use?
fixedSize = GetRLong(DEF_FIXED_SIZE);
if (!fixedSize) fixedSize = FontSize;
// what font to use?
fixedID = GetFontID(GetRString(s,FIXED_FONT));
if (fixedID==applFont)
fixedID = (ScriptVar(smScriptMonoFondSize)>>16)&0xffff;
#endif
// calculate window widths
fixedWidth = GetRLong(DEF_FIXED_MWIDTH)*CharWidthInFont('0',fixedID,fixedSize) + PETE_SCROLLY_DIFFERENCE;
width = MessWi(win);
newWidth = 0;
GetWindowPortBounds(winWP,&rWin);
oldWidth = RectWi(rWin);
// change font
if (GetControlValue(button))
{
PeteFontAndSize(TheBody,kPETEDefaultFont,kPETEDefaultSize);
PeteFontAndSize((*messH)->subPTE,kPETEDefaultFont,kPETEDefaultSize);
if (ABS(oldWidth-fixedWidth)<10) newWidth = width;
ClearMessFlag ( messH, FLAG_FIXED_WIDTH );
}
else
{
PeteFontAndSize(TheBody,fixedID,fixedSize);
// PeteFontAndSize((*messH)->subPTE,fixedID,fixedSize);
if (ABS(oldWidth-width)<10) newWidth = fixedWidth;
SetMessFlag ( messH, FLAG_FIXED_WIDTH );
}
SetControlValue(button,1-value);
// do we need to resize the window?
if (newWidth)
{
SizeWindow(winWP,newWidth,RectHi(rWin),false);
MyWindowDidResize(win,nil);
}
break;
case mcFetch:
SetControlValue(button,1-value);
if (value)
{
RemIdFromPOPD(PERS_POPD_TYPE(MESS_TO_PPERS(messH)),FETCH_ID,SumOf(messH)->uidHash);
if (!PrefIsSet(PREF_LMOS))
{
RemIdFromPOPD(PERS_POPD_TYPE(MESS_TO_PPERS(messH)),DELETE_ID,SumOf(messH)->uidHash);
SetControlValue(FindControlByRefCon(win,mcTrash),0);
HiliteControl(FindControlByRefCon(win,mcTrash),0);
}
}
else
{
AddIdToPOPD(PERS_POPD_TYPE(MESS_TO_PPERS(messH)),FETCH_ID,SumOf(messH)->uidHash,False);
if (!PrefIsSet(PREF_LMOS))
{
AddIdToPOPD(PERS_POPD_TYPE(MESS_TO_PPERS(messH)),DELETE_ID,SumOf(messH)->uidHash,False);
SetControlValue(FindControlByRefCon(win,mcTrash),1);
HiliteControl(FindControlByRefCon(win,mcTrash),255);
}
}
InvalTocBox((*messH)->tocH,(*messH)->sumNum,blServer);
break;
case mcGetGraphics:
HiliteControl(FindControlByRefCon(win,mcGetGraphics),255); // Disabling button indicates that graphics should now be downloaded
PeteRecalc(win->pte);
break;
case mcTrash:
SetControlValue(button,1-value);
if (value) RemIdFromPOPD(PERS_POPD_TYPE(MESS_TO_PPERS(messH)),DELETE_ID,SumOf(messH)->uidHash);
else AddIdToPOPD(PERS_POPD_TYPE(MESS_TO_PPERS(messH)),DELETE_ID,SumOf(messH)->uidHash,True);
InvalTocBox((*messH)->tocH,(*messH)->sumNum,blServer);
break;
}
AuditHit((modifiers&shiftKey)!=0, (modifiers&controlKey)!=0, (modifiers&optionKey)!=0, (modifiers&cmdKey)!=0, false, GetWindowKind(winWP), GetControlReference(button), mouseDown);
}
/************************************************************************
* MessMakeEditable - flip the pencil for a message
************************************************************************/
OSErr MessMakeEditable(MyWindowPtr win, Boolean value)
{
PETEDocInfo info;
MessHandle messH = Win2MessH(win);
PETETextStyle style;
if (!value)
{
PETEGetDocInfo(PETE,TheBody,&info);
if (info.dirty)
{
if (!PrefIsSet(PREF_EZ_SAVE))
{
if (!SaveMessHi(win,False)) return userCanceledErr;
}
else if (!SaveMess(win)) return userCanceledErr;
}
PETESetCallback(PETE,TheBody,nil,peDocChanged);
ClearMessOpt(messH,OPT_WRITE);
win->ro = win->pte==TheBody;
win->userSave = false;
PETEHonorLock(PETE,TheBody,peModLock|peSelectLock);
style.tsLock = peModLock;
PETESetTextStyle(PETE,TheBody,0L,0x7fffffff,&style,peLockValid);
win->isDirty = False;
PeteCleanList(win->pteList);
}
else
{
SetMessOpt(messH,OPT_WRITE);
win->userSave = true;
win->ro = False;
PETESetCallback(PETE,TheBody,(void*)PeteChanged,peDocChanged);
PETEHonorLock(PETE,TheBody,peNoLock);
}
SetControlValue(FindControlByRefCon(win,mcWrite),value);
return noErr;
}
/************************************************************************
* MessGonnaShow - get ready to show a message window
************************************************************************/
OSErr MessGonnaShow(MyWindowPtr win)
{
WindowPtr winWP = GetMyWindowWindowPtr (win);
MessHandle messH = (MessHandle)GetMyWindowPrivateData(win);
short margin;
Rect r;
ControlHandle blah;
Boolean on = MessOnPOPD(POPD_ID,messH);
MControlsEnum cIndex;
short icon;
short value;
long scanned;
Boolean junk = SumOf(messH)->spamScore >= GetRLong(JUNK_MAILBOX_THRESHHOLD);
win->didResize = MessDidResize;
win->key = MessKey;
win->update = MessUpdate;
win->help = MessHelp;
win->button = MessButton;
win->dontControl = True;
win->zoomSize = MessZoomSize;
win->label = SumColor(SumOf(messH));
margin = GetRLong(COMP_TOP_MARGIN);
if (!MessFlagIsSet(messH,FLAG_OUT) && MessOptIsSet(messH,OPT_RECEIPT) && !GetPrefLong(PREF_RECEIPT)) margin += GROW_SIZE+2*INSET;
SetTopMargin(win,margin);
if (MakeSubjectTXE(messH))
{
win->click = win->bgClick = MessClick;
#ifdef USECMM_BAD
win->buildCMenu = MessBuildCMenu;
#endif
}
else
{
PeteCleanList(win->pte);
win->isDirty = False;
CloseMyWindow(winWP);
return(-108);
}
PeteFocus(win,TheBody,True);
(*PeteExtra(TheBody))->containsJunkMail = junk;
SetBGColorsByPers(messH);
/*
* Align headers
*/
//if (GetPrefLong(PREF_DONT_ALIGN_HEADERS)!=2) AlignHeaders(messH);
/*
* some attachments
*/
for (scanned=(*PeteExtra(TheBody))->urlScanned;
scanned!=-1 && scanned<3 K;
scanned=(*PeteExtra(TheBody))->urlScanned)
PeteURLScan(win,TheBody);
for (scanned=(*PeteExtra(TheBody))->quoteScanned;
scanned!=-1 && scanned<3 K;
scanned=(*PeteExtra(TheBody))->quoteScanned)
PeteQuoteScan(TheBody);
(*PeteExtra(TheBody))->emoDesired = !MessFlagIsSet(messH,FLAG_SHOW_ALL);
if ((*PeteExtra(TheBody))->emoDesired && EmoDo())
{
for (scanned=(*PeteExtra(TheBody))->emoScanned;
scanned!=-1 && scanned<3 K;
scanned=(*PeteExtra(TheBody))->emoScanned)
EmoScanPete(TheBody,false);
}
/*
* calculate
*/
PeteCalcOn(TheBody);
/*
* controls
*/
Zero(r);
r.bottom = r.right = 2;
for (cIndex=mcWrite;cIndex<=mcTrash;cIndex++)
{
if (FontIsFixed && cIndex==mcFixed) continue; // only if default font is proportional
blah = GetNewControlSmall(ICON_BAR_CNTL,winWP);
if (blah)
{
EmbedControl(blah,win->topMarginCntl);
SetControlReference(blah,cIndex);
switch (cIndex)
{
case mcWrite:
icon = PENCIL_SICN;
break;
case mcBlahBlah:
icon = BLAH_SICN;
break;
case mcFixed:
icon = FIXED_WIDTH_ICON;
if (!FontIsFixed && !(MessOptIsSet(messH,OPT_HTML)||MessFlagIsSet(messH,FLAG_RICH)) && PrefIsSet(PREF_FIXIFY))
MessButton(win,blah,0,kControlButtonPart);
break;
case mcFetch:
icon = FETCH_SICN;
break;
case mcGetGraphics:
icon = MISSING_IMAGE_ICON;
break;
case mcTrash:
icon = TRASH_SICN;
value = MessOnPOPD(DELETE_ID,messH);
break;
}
SetBevelIcon(blah,icon,0,0,nil);
}
else
{
NoSaves = True;
CloseMyWindow(winWP);
NoSaves = False;
return(-108);
}
}
AddPriorityPopup(messH);
PushGWorld();
SetWindowProxyCreatorAndType(winWP,CREATOR,MAILBOX_TYPE,kOnSystemDisk);
win->proxy = MessProxy;
PopGWorld();
MessIBarUpdate(messH);
/*
* notification stuff
*/
CheckAddNotifyControls(win, messH);
// error notification
AddMessErrNote(messH);
BeenThereDoneThat((*messH)->tocH,(*messH)->sumNum);
HiliteOddReply(messH);
if (AnalSpeakPhrases())
{
(*PeteExtra(TheBody))->taeDesired = true;
(*PeteExtra(TheBody))->taeSpeak = true;
}
if (!win->ro) PETESetCallback(PETE,TheBody,(void*)PeteChanged,peDocChanged);
return(noErr);
}
#define CARBON_NOTIFY_BUTTON_V_ADJUSTMENT 4
/************************************************************************
* CheckAddReturnReceipt - see if we need to add return receipt to this message
************************************************************************/
Boolean CheckAddNotifyControls(MyWindowPtr win, MessHandle messH)
{
Boolean result = false;
if (!MessFlagIsSet(messH,FLAG_OUT) && MessOptIsSet(messH,OPT_RECEIPT) && !FindControlByRefCon(win,NOTIFY_CNTL))
{
if (!GetPrefLong(PREF_RECEIPT))
SetTopMargin(win,GetRLong(COMP_TOP_MARGIN) + GROW_SIZE+2*INSET + 2*CARBON_NOTIFY_BUTTON_V_ADJUSTMENT);
switch(GetPrefLong(PREF_RECEIPT))
{
case 2:
(*messH)->sound = NOTIFY_SOUND;
GenerateReceipt(messH,MDN_DISPLAYED,MDN_DISPLAYED_LOCAL,
MessOptIsSet(messH,OPT_AUTO_OPENED) ? MDN_AUTO_ACTION:MDN_MAN_ACTION,
MDN_AUTO_SENT);
ClearMessOpt(messH,OPT_RECEIPT);
break;
case 1:
ClearMessOpt(messH,OPT_RECEIPT);
break;
case 0:
AddNotifyControls(messH);
result = true;
break;
}
}
return result;
}
/************************************************************************
* function - purpose
************************************************************************/
void AddNotifyControls(MessHandle messH)
{
ControlHandle blah;
MyWindowPtr messWin = (*messH)->win;
WindowPtr messWinWP = GetMyWindowWindowPtr (messWin);
Rect r;
Str255 s;
SetRect(&r,2,2,4,4);
if (blah = GetNewControlSmall(NOTIFY_CNTL,messWinWP))
{
(*messH)->sound = NOTIFY_SOUND;
SetControlReference(blah,NOTIFY_CNTL);
if (gGoodAppearance) EmbedControl(blah,messWin->topMarginCntl);
// add message
if (blah = NewControlSmall(messWinWP,&r,"",False,0,0,1,kControlStaticTextProc,MDN_REQUEST))
{
SetTextControlText(blah,GetRString(s,MDN_REQUEST),nil);
if (gGoodAppearance) EmbedControl(blah,messWin->topMarginCntl);
}
// add separator
if (blah = NewControlSmall(messWinWP,&r,"\p",True,0,0,0,kControlSeparatorLineProc,MDN_REQUEST+1))
if (gGoodAppearance) EmbedControl(blah,messWin->topMarginCntl);
PlaceNotifyControls(messWin);
}
}
/************************************************************************
* function - purpose
************************************************************************/
void PlaceNotifyControls(MyWindowPtr win)
{
WindowPtr winWP = GetMyWindowWindowPtr (win);
Rect r, notifyR, rWin;
ControlHandle blah;
if (blah = FindControlByRefCon(win,NOTIFY_CNTL))
{
ButtonFit(blah);
GetWindowPortBounds(winWP,&rWin);
MoveMyCntl(blah,rWin.right-INSET-ControlWi(blah),win->topMargin-ControlHi(blah)-MAX_APPEAR_RIM-2-CARBON_NOTIFY_BUTTON_V_ADJUSTMENT,0,0);
ShowMyControl(blah);
GetControlBounds(blah,&notifyR);
// add message
r = notifyR;
r.right = r.left - INSET;
r.left = INSET;
InsetRect(&r,0,MAX_APPEAR_RIM-1);
if (blah = FindControlByRefCon(win,MDN_REQUEST))
{
MySetCntlRect(blah,&r);
ShowMyControl(blah);
}
// add separator
r = notifyR;
SetRect(&r,INSET,r.top,rWin.right-INSET,r.top+3);
OffsetRect(&r,0,-5);
if (blah = FindControlByRefCon(win,MDN_REQUEST+1))
{
MySetCntlRect(blah,&r);
ShowMyControl(blah);
}
}
}
/************************************************************************
* AddMessErrNote - add the error note to a message, if need be
************************************************************************/
void AddMessErrNote(MessHandle messH)
{
Rect r,c;
ControlHandle cntl;
mesgErrorHandle mesgErrH;
MyWindowPtr messWin = (*messH)->win;
WindowPtr messWinWP = GetMyWindowWindowPtr (messWin);
/* if this message has a mesgErrH or the toc status is x, add note */
if ((mesgErrH=(*(*messH)->tocH)->sums[(*messH)->sumNum].mesgErrH) || ((*(*messH)->tocH)->sums[(*messH)->sumNum].state==MESG_ERR))
{
// make divider
SetRect(&r,-REAL_BIG,messWin->topMargin-1,REAL_BIG,messWin->topMargin+1);
cntl = NewControlSmall(messWinWP,&r,"",True,0,0,0,kControlSeparatorLineProc,nil);
EmbedControl(cntl,messWin->topMarginCntl);
// add to topmargin
SetTopMargin(messWin,messWin->topMargin+GetMesgErrorsHeight(messWin));
GetMesgErrorsRect(messWin,&r);
// add separator
SetRect(&c,INSET,r.top,messWin->contR.right-INSET,r.top+4); // (jp) 2-6-01 Bug 3637 bottom used to be r.top+3
OffsetRect(&c,0,-5);
if (cntl = NewControlSmall(messWinWP,&c,"\p",True,0,0,0,kControlSeparatorLineProc,mcMesgErrSep))
EmbedControl(cntl,messWin->topMarginCntl);
// add icon
r.top += 3;
SetRect(&c,0,0,16,16);
CenterRectIn(&c,&r);
cntl = NewControlSmall(messWinWP,&c,"",True,MESS_ERR_ICON,0,0,kControlIconSuiteNoTrackProc,mcMesgErrors);
if (cntl && GetControlDataHandle(cntl))
{
(*messH)->sound = NOTIFY_SOUND;
if (gGoodAppearance) EmbedControl(cntl,messWin->topMarginCntl);
}
// add message
r.left = r.right+INSET; r.right = messWin->contR.right-INSET;
if (cntl = NewControlSmall(messWinWP,&r,"",False,0,0,1,kControlStaticTextProc,mcMesgErrText))
{
/* try mesgErrH first. if not, use generic */
if (mesgErrH)
{
SetTextControlText(cntl,LDRef(mesgErrH)->errorStr,nil);
UL(mesgErrH);
}
else
{
Str255 item;
SetTextControlText(cntl,GetRString(item,UNKNOWN_ERR_TEXT),nil);
}
LetsGetSmall(cntl);
ShowMyControl(cntl);
if (gGoodAppearance) EmbedControl(cntl,messWin->topMarginCntl);
}
}
}
/************************************************************************
* PlaceMessErrNote - move the error note to the right spot
************************************************************************/
void PlaceMessErrNote(MessHandle messH)
{
ControlHandle cntl;
MyWindowPtr win = (*messH)->win;
Rect r;
long junk;
short h, dH;
if (cntl=FindControlByRefCon(win,mcMesgErrors))
{
GetMesgErrorsRect(win,&r);
r.left = r.right+INSET; r.right = win->contR.right-INSET;
r.top -= 1;
if (cntl=FindControlByRefCon(win,mcMesgErrText))
{
HideControl(cntl);
MySetCntlRect(cntl,&r);
SetBevelStyle(cntl,0);
GetControlData(cntl,0,kControlStaticTextTextHeightTag,sizeof(short),(void*)&h,&junk);
if (h>RectHi(r))
{
SetBevelStyle(cntl,condense);
GetControlData(cntl,0,kControlStaticTextTextHeightTag,sizeof(short),(void*)&h,&junk);
}
dH = (h - RectHi(r))/2;
if (dH<0)
{
OffsetRect(&r,0,-dH);
r.bottom = r.top + h;
MySetCntlRect(cntl,&r);
}
ShowControl(cntl);
}
}
}
/**********************************************************************
* MessIBarUpdate - update the icon bar
**********************************************************************/
void MessIBarUpdate(MessHandle messH)
{
MControlsEnum cIndex;
ControlHandle blah;
long value;
Boolean on = MessOnPOPD(POPD_ID,messH);
Boolean lmos = PrefIsSet(PREF_LMOS);
Boolean fetch = on && MessOnPOPD(FETCH_ID,messH);
Boolean del = on && (fetch && !lmos || MessOnPOPD(DELETE_ID,messH));
for (cIndex=mcWrite;cIndex<=mcTrash;cIndex++)
if (blah=FindControlByRefCon((*messH)->win,cIndex))
{
value = GetControlValue(blah);
switch (cIndex)
{
case mcWrite:
value = MessOptIsSet(messH,OPT_WRITE);
break;
case mcBlahBlah:
value = MessFlagIsSet(messH,FLAG_SHOW_ALL);
break;
case mcFetch:
value = fetch;
if (!on || !MessFlagIsSet(messH,FLAG_SKIPPED)) HideControl(blah);
(*messH)->hasFetchIcon = IsControlVisible(blah);
break;
case mcGetGraphics:
if (!DisplayGetGraphics((*messH)->win))
HideControl(blah);
else
ShowControl(blah);
break;
case mcFixed:
value = MessFlagIsSet(messH,FLAG_FIXED_WIDTH);
break;
case mcTrash:
value = del;
if (!on) HideControl(blah);
else
{
if (!lmos && fetch) DeactivateControl(blah);
else ActivateControl(blah);
}
(*messH)->hasDelIcon = IsControlVisible(blah);
break;
}
SetControlValue(blah,value);
}
}
#ifdef NEVER
/**********************************************************************
* AlignHeaders - align the header names in a message
**********************************************************************/
void AlignHeaders(MessHandle messH)
{
short len = 0;
short thisLen;
Handle text;
long start, colon, stop, end;
short nPara = 0;
PETEParaInfo pinfo;
PETEGetRawText(PETE,TheBody,&text);
end = SumOf(messH)->bodyOffset - (*messH)->weeded;
/*
* insert all the paragraphs, and store the width of the header name
* in the paragraph indent, and keep track of the max width
*/
for (start=0;start<end;start=stop+1)
{
for (colon=start;colon<end && (*text)[colon]!=':';colon++);
for (stop=colon;stop<end;stop++)
if ((*text)[stop]=='\015' && !IsWhite((*text)[stop+1])) break;
thisLen = TextWidth(LDRef(text),start,colon-start+1);
UL(text);
if (len<thisLen) len = thisLen;
PeteEnsureBreak(TheBody,stop+1);
pinfo.indent = thisLen;
PETESetParaInfo(PETE,TheBody,nPara++,&pinfo,peIndentValid);
}
/*
* Now, go back through the paragraphs and set the margins based
* on the maximum length and the header length stored in the indent
*/
pinfo.tabHandle = nil;
len += 2*FontWidth;
if (thisLen = FontWidth*GetRLong(ALIGN_LIMIT)) len = MIN(len,thisLen);
(*PeteExtra(TheBody))->headers = nPara;
while (nPara--)
{
PETEGetParaInfo(PETE,TheBody,nPara,&pinfo);
pinfo.startMargin = (len-pinfo.indent)<<16;
pinfo.indent = (-pinfo.indent-FontWidth)<<16;
PETESetParaInfo(PETE,TheBody,nPara,&pinfo,peIndentValid|peStartMarginValid);
}
}
#endif
/**********************************************************************
* ExportHTMLSum - export html from a message summary
**********************************************************************/
OSErr ExportHTMLSum(TOCHandle tocH,short sumNum)
{
MessHandle messH = (*tocH)->sums[sumNum].messH;
MyWindowPtr win = nil;
OSErr err;
// if this is an IMAP message, make sure it's been downloaded.
if ((*tocH)->imapTOC) EnsureMsgDownloaded(tocH, sumNum, false);
if (!messH)
{
win = GetAMessage(tocH,sumNum,nil,nil,false);
if (!win) return(MemError());
messH = Win2MessH(win);
}
err = ExportHTML(messH);
if (win) CloseMyWindow(GetMyWindowWindowPtr(win));
return(err);
}
#ifdef USE_FANCY_HTML_EXPORT
/**********************************************************************
*
**********************************************************************/
OSErr ExportHTML(MessHandle messH)
{
OSErr err;
Str31 html;
Str31 testMe;
Boolean neg;
short inHTML = 0;
long offset, startOffset, endOffset;
FSSpec spec;
short refN;
UHandle cache;
long len = 0;
long grandLen;
Byte less = '<';
Zero(spec);
if (!(err=CacheMessage((*messH)->tocH,(*messH)->sumNum)))
{
cache = SumOf(messH)->cache;
HNoPurge(cache);
ComposeString(html,"\p%r>",HTMLDirectiveStrn+htmlXHTMLDir);
if (!(err=NewTempExtSpec(Root.vRef,nil,HTML_SUFFIX,&spec)) &&
!(err=FSpCreate(&spec,0L,'TEXT',smSystemScript)) &&
!(err=FSpOpenDF(&spec,fsRdWrPerm,&refN)))
{
LDRef(cache);
grandLen = GetHandleSize(cache);
startOffset = grandLen;
for(offset = SearchPtrHandle(&less,1,cache,0,True,False,nil);
offset>0;
offset = SearchPtrHandle(&less,1,cache,offset+1,True,False,nil))
{
/*
* what is the word we're looking at?
*/
if ((*cache)[offset+1]=='/')
{
neg = True;
MakePStr(testMe,*cache+offset+2,*html);
}
else
{
neg = False;
MakePStr(testMe,*cache+offset+1,*html);
}
/*
* no-brainers first
*/
if (!StringSame(html,testMe)) continue; //anything that's not html is insignificant
if (neg && !inHTML) continue; //hmmm. </html> in free text. No likee.
if (!neg && inHTML) {inHTML++; continue;} // more deeply nested html
/*
* ok, first let's look at <html>
*/
if (!neg)
{
if (!inHTML) startOffset = offset; //html begins
inHTML++;
}
/*
* ok, now the fun one: </html>
*/
else
{
inHTML--;
if (!inHTML)
{
endOffset = offset+*html+3;
endOffset = MIN(endOffset,grandLen);
if (startOffset<endOffset)
{
len = endOffset-startOffset;
err = HTMLWriteForBrowser(cache,startOffset,len,refN);
if (err) goto out;
}
offset = endOffset;
}
}
}
out:
if (!err && inHTML)
{
len = grandLen-startOffset;
err = HTMLWriteForBrowser(cache,startOffset,len,refN);
}
UL(cache);
FSClose(refN);
}
HPurge(cache);
}
// an error occurred if we didn't actually write anything to the temp file -JDB 290499
if (!err && (len ==0)) err = eofErr;
/*
* Did we get some?
*/
if (!err)
{
AliasHandle browser=nil;
FSSpec browserSpec;
Boolean wasChanged;
if (HaveTheDiseaseCalledOSX() && !PrefIsSet(PREF_USE_OWN_URL_HELPERS))
err = OpenOtherDoc(&spec,false,false,nil);
else
{
if (!(err=FindURLApp(GetRString(html,HTTP),&browser,kWildCardOK)))
if (!(err=ResolveAlias(nil,browser,&browserSpec,&wasChanged)))
err = OpenDocWith(&spec,&browserSpec,false);
ZapHandle(browser);
}
}
if (err) FSpDelete(&spec);
if (err && err!=userCancelled && err!=1) return(WarnUser(SAVING_HTML,err));
return err;
}
#else
/**********************************************************************
*
**********************************************************************/
OSErr ExportHTML(MessHandle messH)
{
OSErr err;
Str31 html;
Str31 testMe;
Boolean neg;
short inHTML = 0;
long offset, startOffset, endOffset;
FSSpec spec;
short refN;
UHandle cache;
long len;
long grandLen;
Byte less = '<';
Zero(spec);
if (!(err=CacheMessage((*messH)->tocH,(*messH)->sumNum)))
{
cache = SumOf(messH)->cache;
HNoPurge(cache);
ComposeString(html,"\p%r>",HTMLTagsStrn+htmlTag);
if (!(err=NewTempExtSpec(Root.vRef,nil,HTML_SUFFIX,&spec)) &&
!(err=FSpCreate(&spec,CREATOR,'TEXT',smSystemScript)) &&
!(err=FSpOpenDF(&spec,fsRdWrPerm,&refN)))
{
LDRef(cache);
grandLen = GetHandleSize(cache);
startOffset = grandLen;
for(offset = SearchPtrHandle(&less,1,cache,0,True,False,nil);
offset>0;
offset = SearchPtrHandle(&less,1,cache,offset+1,True,False,nil))
{
/*
* what is the word we're looking at?
*/
if ((*cache)[offset+1]=='/')
{
neg = True;
MakePStr(testMe,*cache+offset+2,*html);
}
else
{
neg = False;
MakePStr(testMe,*cache+offset+1,*html);
}
/*
* no-brainers first
*/
if (!StringSame(html,testMe)) continue; //anything that's not html is insignificant
if (neg && !inHTML) continue; //hmmm. </html> in free text. No likee.
if (!neg && inHTML) {inHTML++; continue;} // more deeply nested html
/*
* ok, first let's look at <html>
*/
if (!neg)
{
if (!inHTML) startOffset = offset; //html begins
inHTML++;
}
/*
* ok, now the fun one: </html>
*/
else
{
inHTML--;
if (!inHTML)
{
endOffset = offset+*html+3;
endOffset = MIN(endOffset,grandLen);
if (startOffset<endOffset)
{
len = endOffset-startOffset;
err = AWrite(refN,&len,*cache+startOffset);
if (err) goto out;
}
offset = endOffset;
}
}
}
out:
if (!err && inHTML)
{
len = grandLen-startOffset;
err = AWrite(refN,&len,*cache+startOffset);
}
UL(cache);
FSClose(refN);
}
HPurge(cache);
}
/*
* Did we get some?
*/
if (!err)
{
AliasHandle browser=nil;
FSSpec browserSpec;
Boolean wasChanged;
if (!(err=FindURLApp(GetRString(html,HTTP),&browser,kWildCardOK)))
if (!(err=ResolveAlias(nil,browser,&browserSpec,&wasChanged)))
err = OpenDocWith(&spec,&browserSpec);
ZapHandle(browser);
}
if (err) FSpDelete(&spec);
if (err && err!=userCancelled && err!=1) return(WarnUser(SAVING_HTML,err));
}
#endif
/**********************************************************************
* HiliteOddReply - hilite reply-to: and friends in color
**********************************************************************/
void HiliteOddReply(MessHandle messH)
{
Str255 scratch, scratch2;
UHandle text;
short r;
long size;
HeadSpec hs, fromHS;
PETETextStyle ts;
PETEGetRawText(PETE,TheBody,&text);
LDRef(text);
size = GetHandleSize(text);
for (r=1;*GetRString(scratch,ReplyStrn+r);r++)
{
if (EqualStrRes(scratch,HEADER_STRN+FROM_HEAD)) break;
if (CompHeadFindStr(messH,scratch,&hs))
{
if (CompHeadFindStr(messH,GetRString(scratch,HEADER_STRN+FROM_HEAD),&fromHS))
{
MakePStr(scratch,(*text)+hs.value,hs.stop-hs.value);
MakePStr(scratch2,(*text)+fromHS.value,fromHS.stop-fromHS.value);
if (SameAddressStr(scratch,scratch2)) continue;
}
ts.tsLabel = pReplyLabel;
PETESetTextStyle(PETE,TheBody,hs.start,hs.stop,&ts,peLabelValid);
PeteCleanList(TheBody);
if (!MessOptIsSet(messH,OPT_WEIRD_REPLY)) SetMessOpt(messH,OPT_WEIRD_REPLY);
}
}
UL(text);
}
/************************************************************************
* MessUpdate - update a message window
************************************************************************/
void MessUpdate(MyWindowPtr win)
{
WindowPtr winWP = GetMyWindowWindowPtr (win);
if (IsWindowVisible (winWP))
{
MessHandle messH = (MessHandle)GetMyWindowPrivateData(win);
if (IsWindowVisible (winWP) && (*messH)->sound)
{
Str255 soundName;
PlayNamedSound(GetRString(soundName,(*messH)->sound));
(*messH)->sound = 0;
}
}
}
#ifdef TWO
/**********************************************************************
* MessBuildDragRgn - build the drag region for a message
**********************************************************************/
RgnHandle MessBuildDragRgn(MessHandle messH)
{
WindowPtr messWinWP = GetMyWindowWindowPtr ((*messH)->win);
RgnHandle rgn = NewRgn();
if (rgn)
{
GetWindowRegion(messWinWP,kWindowTitleProxyIconRgn,rgn);
LocalizeRgn(rgn);
}
return(rgn);
}
/**********************************************************************
* GetServerRect - get rectangle for a server icon
**********************************************************************/
Boolean GetServerRect(MyWindowPtr win, short which, Rect *r)
{
CGrafPtr winPort = GetMyWindowCGrafPtr (win);
short wi;
Rect rPort;
GetBlahRect(win,0,r);
wi = r->right - r->left;
GetPortBounds(winPort,&rPort);
r->right = rPort.right-(2-which)*(INSET+wi)-INSET;
r->left = r->right-wi;
return(True);
}
#endif
/**********************************************************************
* GetMesgErrorsHeight - get rectangle for a transport errors icon
**********************************************************************/
short GetMesgErrorsHeight(MyWindowPtr win)
{
short height, fs;
FontInfo info;
fs = GetPortTextSize(GetQDGlobalsThePort());
TextSize (10);
GetFontInfo(&info);
TextSize (fs);
height = (info.ascent + info.descent + info.leading) * 2;
return ((height < MESG_ERR_WIDTH) ? MESG_ERR_WIDTH : height);
}
/**********************************************************************
* GetMesgErrorsRect - get rectangle for a transport errors icon
**********************************************************************/
Boolean GetMesgErrorsRect(MyWindowPtr win, Rect *r)
{
CGrafPtr winPort = GetMyWindowCGrafPtr (win);
Rect rPort;
GetPortBounds(winPort,&rPort);
r->left = rPort.left + INSET;
r->right = r->left + MESG_ERR_WIDTH;
r->bottom = win->topMargin - MAX_APPEAR_RIM;
r->top = r->bottom - MESG_ERR_WIDTH + 6;
return(True);
}
/************************************************************************
* MessFocus - switch txe's in a message window
************************************************************************/
void MessFocus(MessHandle messH,PETEHandle pte)
{
MyWindowPtr win = (*messH)->win;
Boolean wasSub = win->pte==(*messH)->subPTE;
PeteFocus(win,pte,True);
win->ro = win->pte==TheBody && !MessOptIsSet(messH,OPT_WRITE);
if (wasSub && win->pte!=(*messH)->subPTE)
MessSaveSub(messH);
else win->showInsert = NOOP;
}
/**********************************************************************
* MessSaveSub - save the subject of a message
**********************************************************************/
OSErr MessSaveSub(MessHandle messH)
{
Str255 newSubj;
if(MessFlagIsSet(messH, FLAG_UTF8) && HasUnicode())
{
OSErr err;
long iUsed, oUsed;
err = PeteGetUTF8Text((*messH)->subPTE, 0, LONG_MAX, &iUsed, &(newSubj[1]), sizeof(newSubj) - 1, &oUsed);
if(err && err != kTECOutputBufferFullStatus) return err;
newSubj[0] = oUsed;
}
else
{
PeteSString(newSubj,(*messH)->subPTE);
}
SetSubject((*messH)->tocH,(*messH)->sumNum,newSubj);
PETEMarkDocDirty(PETE,(*messH)->subPTE,False);
if (PeteIsDirtyList((*messH)->win->pteList)) (*messH)->win->isDirty = True;
else (*messH)->win->isDirty = False;
return noErr;
}
/************************************************************************
* MessDidResize - resize a message window
************************************************************************/
void MessDidResize(MyWindowPtr win, Rect *oldContR)
{
MessHandle messH = (MessHandle)GetMyWindowPrivateData(win);
Rect view;
Rect paneR;
PETEHandle bodTeh = TheBody;
PETEHandle subTeh = (*messH)->subPTE;
ControlHandle blah,
errorCntl = nil;
if (!subTeh)
TextDidResize(win,oldContR);
else
{
view = win->contR;
PeteDidResize(bodTeh,&view);
}
PlaceMessErrNote(messH);
if (!oldContR || oldContR->right-oldContR->left!=win->contR.right-win->contR.left)
{
SetRect(&view,0,0,REAL_BIG/2,win->topMargin-3);
InvalWindowRect(GetMyWindowWindowPtr(win),&view);
/*
* the icon bar
*/
if (GetBlahRect(win,0,&view))
{
if (blah = FindControlByRefCon(win,mcWrite))
MySetCntlRect(blah,&view);
GetBlahRect(win,1,&view);
if (blah=FindControlByRefCon(win,mcBlahBlah))
MySetCntlRect(blah,&view);
GetBlahRect(win,2,&view);
if (blah=FindControlByRefCon(win,mcFixed))
MySetCntlRect(blah,&view);
GetServerRect(win,1,&view);
if (blah=FindControlByRefCon(win,mcFetch))
MySetCntlRect(blah,&view);
GetServerRect(win,1,&view);
if (blah=FindControlByRefCon(win,mcGetGraphics))
MySetCntlRect(blah,&view);
GetServerRect(win,2,&view);
if (blah=FindControlByRefCon(win,mcTrash))
MySetCntlRect(blah,&view);
if (blah=FindControlByRefCon(win,NOTIFY_CNTL))
{
PlaceNotifyControls(win);
}
MessSubjRect(win,&view);
paneR = view;
if (blah=FindControlByRefCon(win,(uLong)subTeh))
{
InsetRect(&paneR,-MAX_APPEAR_RIM,-MAX_APPEAR_RIM);
SetControlVisibility(blah,false,false);
MySetCntlRect(blah,&paneR);
SetControlVisibility(blah,true,false);
}
PETESizeDoc(PETE,subTeh,RectWi(view),RectHi(view));
PETEChangeDocWidth(PETE,win->pte,-1,True);
}
}
}
/************************************************************************
* MessSubjRect - find the rect for the subject teh
************************************************************************/
void MessSubjRect(MyWindowPtr win,Rect *r)
{
MessHandle messH = Win2MessH(win);
short hi = ONE_LINE_HI(win);
Rect pr, br;
GetPriorityRect(win,&pr);
GetBlahRect(win,FontIsFixed?1:2,&br);
pr.right = br.right;
*r = win->contR;
r->left += pr.right + INSET+win->hPitch;
r->top = pr.top + (RectHi(pr)-hi-1)/2;
r->bottom = r->top + hi;
#ifdef TWO
GetServerRect(win,1,&br);
r->right = br.left-INSET;
#endif
}
/************************************************************************
* GetBlahRect - get the rect for the blah blah icon
************************************************************************/
Boolean GetBlahRect(MyWindowPtr win, short which, Rect *r)
{
if (!GetPriorityRect(win,r)) return(False);
OffsetRect(r,(which+1)*(RectWi(*r)+INSET),0);
return(True);
}
/************************************************************************
* MessCursor - set the cursor properly
************************************************************************/
void MessCursor(Point mouse)
{
MyWindowPtr win=GetWindowMyWindowPtr(FrontWindow_());
MessHandle messH = Win2MessH(win);
if (!PeteCursorList(win->pteList,mouse))
SetMyCursor(arrowCursor);
}
/************************************************************************
* GetPriorityRect - where does the priority thing belong?
************************************************************************/
Boolean GetPriorityRect(MyWindowPtr win,Rect *pr)
{
if (!win->topMargin)
{
SetRect(pr,0,0,0,0);
return(False);
}
else
{
pr->left = INSET;
pr->top = 2*MAX_APPEAR_RIM+2;
pr->bottom = pr->top+22;
pr->right = pr->left+22;
return(True);
}
}
/************************************************************************
* DrawPriority - draw the message priority
************************************************************************/
void DrawPriority(Rect *pr,short p)
{
WindowPtr theWindow = GetWindowFromPort(GetQDGlobalsThePort());
Rect ir;
if (GetWindowKind(theWindow)!=CBOX_WIN &&GetWindowKind(theWindow)!=MBOX_WIN)
{
ir = *pr;
InsetRect(&ir,-2,-2);
EraseRect(&ir);
FrameRect(&ir);
MoveTo(ir.left+1,ir.bottom);
Line(ir.right-ir.left-1,0);
Line(0,ir.top-ir.bottom+1);
}
p = Prior2Display(p);
SetRect(&ir,0,0,16,16);
CenterRectIn(&ir,pr);
if (p==pymRaise)
PlotIconID(&ir,atAbsoluteCenter, ttNone,RAISE_PRIOR_SICN);
else if (p==pymLower)
PlotIconID(&ir,atAbsoluteCenter, ttNone,LOWER_PRIOR_SICN);
else
PlotIconID(&ir,atAbsoluteCenter, ttNone,PRIOR_SICN_BASE+p-1);
}
/************************************************************************
* SetMessTable - set the xlit table for a message
************************************************************************/
void SetMessTable(TOCHandle tocH, short sumNum, short newId)
{
if ((*tocH)->sums[sumNum].tableId!=newId)
{
(*tocH)->sums[sumNum].tableId = newId;
TOCSetDirty(tocH,true);
if ((*tocH)->previewID==(*tocH)->sums[sumNum].serialNum) (*tocH)->previewID = 0;
if ((*tocH)->which!=OUT && (*tocH)->sums[sumNum].messH)
ReopenMessage((*(*tocH)->sums[sumNum].messH)->win);
}
}
/************************************************************************
* MessZoomSize - figure the size of a message window
************************************************************************/
void MessZoomSize(MyWindowPtr win,Rect *zoom)
{
long wi, hi;
PETEHandle pte = (*Win2MessH(win))->bodyPTE;
PETEDocInfo info;
wi = MessWi(win);
zoom->right = zoom->left + MIN(zoom->right-zoom->left,wi);
if (PeteIsValid(pte))
{
//PETEGetDocInfo(PETE,pte,&info);
wi = zoom->right-zoom->left-PETE_SCROLLY_DIFFERENCE+9;
PETEChangeDocWidth(PETE,pte,wi,True);
PETEGetDocInfo(PETE,pte,&info);
hi = info.docHeight + win->topMargin + win->vPitch;
if (hi<zoom->bottom-zoom->top)
zoom->bottom = zoom->top + hi;
}
}
/**********************************************************************
* MessWi - how wide is a window?
**********************************************************************/
short MessWi(MyWindowPtr win)
{
short wi;
if (!(wi=GetPrefLong(PREF_MWIDTH))) wi=GetRLong(DEF_MWIDTH);
wi *= win->hPitch; wi += PETE_SCROLLY_DIFFERENCE;
return(wi);
}
/************************************************************************
* MessApp1 - scroll the message, not the subject
************************************************************************/
Boolean MessApp1(MyWindowPtr win,EventRecord *event)
{
event->what=keyDown;
PeteEdit(win,(*Win2MessH(win))->bodyPTE,peeEvent,(void*)event);
return(True);
}
/************************************************************************
* IncrementQuoteLevel - adjust the quote level in a message
************************************************************************/
OSErr IncrementQuoteLevel(PETEHandle pte,long start, long stop,short increment)
{
OSErr err;
short fromPara, toPara;
PETEParaInfo pInfo;
PETEStyleEntry pse;
short level;
// I'm only going to tell you this once...
pse.psStyle.textStyle.tsLabel = pQuoteLabel;
Zero(pInfo);
// avoid messy redraw
PeteCalcOff(pte);
// Expand offsets to para boundaries
start = stop = -1; // use selection
PeteParaRange(pte,&start,&stop);
PeteParaConvert(pte,start,stop);
// Undo to para boundaries
PetePrepareUndo(pte,peUndoStyleAndPara,start,stop,nil,nil);
// Find the start and stop points
fromPara = PeteParaAt(pte,start);
toPara = PeteParaAt(pte,stop-1);
toPara = MAX(toPara,fromPara); // darn fiddly end conditions
// Ok, do some work
for (;fromPara<=toPara;fromPara++)
{
// get current quote level
if (err = PETEGetParaInfo(PETE,pte,fromPara,&pInfo)) break;
// bump it, but don't allow negative or > 15
level = pInfo.quoteLevel + increment;
level = MIN(level,15);
level = MAX(level,0);
pInfo.quoteLevel = level;
// and set it
if (err = PETESetParaInfo(PETE,pte,fromPara,&pInfo,peQuoteLevelValid)) break;
// and give it the quote label
if (level) PETESetTextStyle(PETE,pte,pInfo.paraOffset,pInfo.paraOffset+pInfo.paraLength,&pse.psStyle.textStyle,pQuoteLabel<<kPETELabelShift);
}
// And finish it off with a little undo
if (err) PeteKillUndo(pte);
else PeteFinishUndo(pte,peUndoStyleAndPara,start,stop);
// now draw
PeteCalcOn(pte);
return(err);
}
#ifdef USECMM_BAD
/************************************************************************************************
MessBuildCMenu - build a list of context-specific items to be added to the contextual menu when
the context click occurs over a recevied message window. specCMenuInfo does not point to a valid
handle upon calling the function. The handle-style array it points to needs to be allocated
herein.
************************************************************************************************/
OSStatus MessBuildCMenu(MyWindowPtr win, EventRecord* contextEvent, MenuHandle contextMenu)
{
short numItems; //number of items to add put into the list
static CMenuInfo locCMInfo[] = //items to put into the list
{ MESSAGE_MENU, MESSAGE_REPLY_ITEM, //"reply" item
MESSAGE_MENU, MESSAGE_FORWARD_ITEM, //"forward" item
MESSAGE_MENU, MESSAGE_DELETE_ITEM, //"delete" item
CONTEXT_MENU, CONTEXT_TERM_ITEM }; //item to mark end of array
//count the number of items to add
for( numItems=0; !( locCMInfo[numItems].srcMenuID == CONTEXT_MENU && locCMInfo[numItems].srcMenuItem == CONTEXT_TERM_ITEM); numItems++ )
;
//allocate memory for as handle-style array
*specCMenuInfo = (CMenuInfoHndl)NewHandle( sizeof( CMenuInfo ) * ( numItems + 1 ) );
if( !(*specCMenuInfo) ) return( MemError() );
//copy data into the array
BlockMove( locCMInfo, **specCMenuInfo, sizeof( CMenuInfo ) * ( numItems + 1 ) );
return( noErr );
}
#endif
Reference in New Issue View Git Blame Copy Permalink