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/trans.c

1 line
150 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 "trans.h"
#include "tlapi-MacGlue.h"
#define FILE_NUM 75
/* Copyright (c) 1995 by QUALCOMM Incorporated */
#ifdef TWO
#pragma segment TRANSLATOR
#if TARGET_RT_MAC_CFM
#define SIMPLE_UPP(routine,what) \
routine##Type routine;\
RoutineDescriptor routine##RD = BUILD_ROUTINE_DESCRIPTOR(upp##what##ProcInfo,routine);\
what routine##UPP=(what)&routine##RD
#else
#define SIMPLE_UPP(routine,what) \
routine##Type routine;\
what##UPP routine##UPP = (void*)&routine
#endif
#ifdef ETL
#ifdef DEBUG
//#define DEBUGFILES // Create debug files
#endif
TLMHandle TLSelList, TLQ4List, TLAttachList, TLSpecialList, TLSettingList, TLModelessList, TLImporterList;
#define tlInstance void*
typedef struct
{
tlInstance instance;
tlStringHandle moduleDescription;
short moduleID;
Handle moduleSuite;
short version; // Used to determine what plugin supports (like parameter-block style functions version 3+)
long idleTimeFreq;
long lastIdleTime;
long pluginKey;
short numMBoxContext;
short tCount;
ModeTypeEnum modeNeeded;
Boolean downgradeWasBeingUsed;
} TLFuncList, *TLFLPtr, **TLFLHandle;
TLFLHandle TLFL;
typedef tlStringHandle **tlAddrListHandle;
// Keeps track of signature bar offsets within the file
enum { kMaxSignList = 16 };
typedef struct
{
short count;
long begin[kMaxSignList];
long end[kMaxSignList];
} SignOffsetList;
SignOffsetList *gpSignList;
void ETLAddAppleItem(void);
void ETLFillMailConfig(emsMailConfigP mailConfig, emsCallBacksP callBacks, Boolean useOldMailConfig);
void ETLEmptyMailConfig(emsMailConfigP mailConfig);
OSErr PlainTextMIMEStuff(emsMIMEHandle *emsMIME,Handle *headers);
OSErr ETLListRequestedTranslators(TLMHandle *translators, TransInfoHandle hRequested);
short ETLError(tlStringHandle description,short context,tlStringHandle errorStr,OSErr err,long tlErr);
short ETLOpenModules(AccuPtr instances);
void DisposeTLMIMEParam(emsMIMEParamHandle param);
int ETLCompare(TLMPtr t1,TLMPtr t2);
void ETLSwap(TLMPtr t1,TLMPtr t2);
void ETLSortTranslators(TLMHandle translators);
OSErr ETLOutputHandle(UHandle text,short refN,AccuPtr a);
OSErr ETLOutputPtr(UPtr text,long size,short refN,AccuPtr a);
#define ETLOutputStr(s,r,a) ETLOutputPtr((s)+1,*(s),(r),(a))
OSErr ETLGetTLMIME(FSSpecPtr spec,emsMIMEHandle *tlMIME);
OSErr ETLCopyFile(FSSpecPtr spec,short refN,Boolean display,HeaderDHandle *theHeaders);
OSErr ETLReadTLMIME(FSSpecPtr spec,emsMIMEHandle *tlMIME);
OSErr ETLBuildOldAddrList(MessHandle messH,tlAddrListHandle *addrList,Boolean expandNicks);
static OSErr ETLTranslate(TLMHandle translators,short context,emsMIMEHandle emsMIME,FSSpecPtr source,emsMIMEHandle *emsMIMEOut,tlStringHandle *textOut,FSSpecPtr into,tlStringHandle *errorStr,long *errCode,emsHeaderDataP addrList);
static OSErr ETLTransOutLow(TLMHandle transList,emsHeaderDataP addrList,emsMIMEHandle tlMIME,FSSpecPtr from,FSSpecPtr to,MessHandle messH);
static void DisposeOldAddrList(tlAddrListHandle addrList);
OSErr ETLTransHandleBuf(UHandle *text,TLMPtr tlm);
static OSErr ETLTransHandleFile(UHandle *text,TLMPtr tlm,PETEHandle pte);
void ETLAboutButton(MyWindowPtr win,ControlHandle button,long modifiers,short part);
void ETLAboutUpdate(MyWindowPtr win);
Boolean ETLAboutClose(MyWindowPtr win);
Boolean ETLKey(MyWindowPtr win, EventRecord *event);
void ETLAboutClick(MyWindowPtr win, EventRecord *event);
static emsAddressH GetAddressesFromHandle(Uhandle text,Boolean expandNicks);
static emsAddressH FindAddress(Accumulator acc, short index,Boolean expandNicks);
OSErr ETLAddVolatileMenus(void);
#define SetSize(x) (x).size = sizeof(x);
static OSErr GetTransIcon(TLFLPtr tlfl,long id,Handle *suite);
static OSErr CanTranslateFile(TLFLPtr pTLFL,long context,short trans_id,
emsMIMEHandle in_mime,StringPtr **out_error,
long *out_code, StringPtr *queuedProperties, emsHeaderDataP header, MessHandle messH);
static OSErr MyTranslateFile(TLFLPtr pTLFL,long context,short trans_id,
emsMIMEHandle in_mime,FSSpec *in_file,emsMIMEHandle *out_mime,
FSSpec *out_file,Handle *out_icon,StringPtr **out_desc,StringPtr **out_error,
long *out_code, StringHandle queuedProperties, emsHeaderDataP header, MessHandle messH, Handle translatorName);
static tlMIMEtypeP DegradeMIME(emsMIMEHandle inMIME);
static emsMIMEHandle UpgradeMIME(tlMIMEtypeP inMIME);
static void DisposeOldTLMIME(tlMIMEtypeP tlMIME);
static void DisposeOldTLMIMEParam(tlMIMEParamP param);
static tlMIMEParamP DegradeMIMEParam(emsMIMEparamH hParam);
static OSErr NewMIME(emsMIMEHandle *tlMIME,short mimeType,short subType);
static StringHandle GetQueuedProperties(MessHandle messH,long id);
static emsAddressH MakeAddress(StringPtr sAddress,StringPtr sName);
static void ZapAddress(emsAddressH address);
static Boolean IsSystemComponent(Component comp);
static OSErr QueuedProperties(short which, long *selected, StringHandle *pProperties,Boolean fDefaultOn);
static void GetContextIconRect(Rect *rContentBox, Rect *rIcon);
static Boolean PluginIDToIndex(long key,short *index);
static void CheckAddToToolbar(TLMHandle hTLM, MenuHandle hMenu);
static emsAddressH GetAddressesFromHeader(UHandle textIn,short header,Boolean expandNicks);
#define ContextRequiresExpansion(context) (((context)&(EMSF_Q4_COMPLETION+EMSF_Q4_TRANSMISSION))!=0)
// Global variables
short gIdleTimeCount; // # of plug-ins that want idle time
long gPluginDrain;
unsigned long gTranslatorFlags; // All flags set by any translator
// List of components in System Folder. So we don't unregister
// any components installed a system startup time.
Component **ghSystemComponents;
// Callback function declarations and UPP's
typedef pascal short ETLProgressType(short percent);
SIMPLE_UPP(ETLProgress,tlProgress); // v1
typedef pascal short ETLProgress3Type(emsProgressDataP progData);
SIMPLE_UPP(ETLProgress3,emsProgress); // v3
typedef pascal void ETLGetMailboxType(emsGetMailBoxDataP getMailBoxData);
SIMPLE_UPP(ETLGetMailbox,emsGetMailBox); // v4
typedef pascal void ETLSetMailBoxTagType(emsSetMailBoxTagDataP setMailBoxTagData);
SIMPLE_UPP(ETLSetMailBoxTag,emsSetMailBoxTag);
typedef pascal void ETLGetMailBoxTagType(emsSetMailBoxTagDataP setMailBoxTagData);
SIMPLE_UPP(ETLGetMailBoxTag,emsGetMailBoxTag); // v5
typedef pascal short ETLGetPersonalityType(emsGetPersonalityDataP getPersonalityData);
SIMPLE_UPP(ETLGetPersonality,emsGetPersonality);
typedef pascal short ETLGetPersonalityInfoType(emsGetPersonalityInfoDataP getPersonalityData);
SIMPLE_UPP(ETLGetPersonalityInfo,emsGetPersonalityInfo);
typedef pascal void ETLRegenerateType(emsRegenerateDataP RegenerateData);
SIMPLE_UPP(ETLRegenerate,emsRegenerate);
typedef pascal short ETLGetDirectoryType(emsGetDirectoryDataP GetDirectoryData);
SIMPLE_UPP(ETLGetDirectory,emsGetDirectory);
typedef pascal void ETLUpdateWindowsType(void);
SIMPLE_UPP(ETLUpdateWindows,emsUpdateWindows);
typedef pascal short ETLPlugwindowRegisterType(emsPlugwindowDataP wd);
SIMPLE_UPP(ETLPlugwindowRegister,emsPlugwindowRegister);
typedef pascal void ETLPlugwindowUnRegisterType(emsPlugwindowDataP wd);
SIMPLE_UPP(ETLPlugwindowUnRegister,emsPlugwindowUnRegister);
typedef pascal void ETLGDeviceRgnType(emsGDeviceRgnDataP wd);
SIMPLE_UPP(ETLGDeviceRgn,emsGDeviceRgn);
typedef pascal void ETLSelectWindowType(WindowPtr wp);
SIMPLE_UPP(ETLSelectWindow,emsSelectWindow);
typedef pascal WindowPtr ETLFrontWindowType(void);
SIMPLE_UPP(ETLFrontWindow,emsFrontWindow);
typedef pascal short ETLMakeSigType(emsMakeSigDataP makeSigData);
SIMPLE_UPP(ETLMakeSig,emsMakeSig); // v6
typedef pascal short ETLMakeAddressBookType(emsMakeAddressBookDataP makeSigData);
SIMPLE_UPP(ETLMakeAddressBook,emsMakeAddressBook);
typedef pascal short ETLMakeABEntryType(emsMakeABEntryDataP makeABEntryData);
SIMPLE_UPP(ETLMakeABEntry,emsMakeABEntry);
typedef pascal short ETLMakeMailboxType(emsMakeMailboxDataP makeMailboxData);
SIMPLE_UPP(ETLMakeMailbox,emsMakeMailbox);
typedef pascal short ETLMakeOutMessType(emsMakeOutMessDataP makeOutMessData);
SIMPLE_UPP(ETLMakeOutMess,emsMakeOutMess);
typedef pascal short ETLMakeMessageType(emsMakeMessageDataP MakeMessageData);
SIMPLE_UPP(ETLMakeMessage,emsMakeMessage);
typedef pascal short ETLCreateMailBoxType(emsCreateMailBoxDataP createMailboxData);
SIMPLE_UPP(ETLCreateMailBox,emsCreateMailBox);
typedef pascal short ETLIsInAddressBookType(emsIsInAddressBookDataP isInAddressBookData);
SIMPLE_UPP(ETLIsInAddressBook,emsIsInAddressBook);
typedef pascal short ETLImportMboxType(emsImportMboxDataP importMBoxData);
SIMPLE_UPP(ETLImportMbox,emsImportMbox);
#define TO_UPP_OR_NOT_TO_UPP(proc) (HaveOSX() ? proc : proc##UPP)
// Use parameter-block style functions? (version 3+)
#define UseParameterBlockStyleFunctions(version) (version >= EMS_PB_VERSION)
// Use old mail config? (versions before 7)
#define UseOldMailConfig(version) (version < EMS_NEW_MAIL_CONFIG_VERSION)
/**********************************************************************
* Functions for managing modules
**********************************************************************/
// carbon build looks for 'ecTL' type plugins when running under OS X
#define TL_COMPONENT_TYPE (HaveOSX() ? 'ecTL' : 'euTL')
/**********************************************************************
* ETLOpenModules - open & count the translator modules
* Returns:
* # of translator modules
**********************************************************************/
short ETLOpenModules(AccuPtr instances)
{
ComponentDescription looking;
Component index=nil;
Component lastComponent=nil;
tlInstance instance;
Boolean retry;
if (!AccuInit(instances))
{
#ifdef DEBUG
#ifdef NO_EMSAPI_INIT
if (RunType!=Debugging)
#endif
#endif
do
{
Zero(looking);
looking.componentType = TL_COMPONENT_TYPE;
retry = False;
if (index = FindNextComponent(index, &looking))
{
if (instance=OpenComponent(index))
{
lastComponent = index;
AccuAddPtr(instances,(void*)&instance,sizeof(instance));
}
else
{
ASSERT(0);
UnregisterComponent(index);
index = lastComponent;
retry = True;
}
}
}
while(retry || index);
return(instances->offset/sizeof(instance));
}
return(0);
}
/**********************************************************************
* ETLGetSystemPlugins - get plugins that were already installed
* and record so we don't unregister them on cleanup
**********************************************************************/
void ETLGetSystemPlugins(void)
{
ComponentDescription looking;
Component index=nil;
do
{
Zero(looking);
looking.componentType = TL_COMPONENT_TYPE;
if (index = FindNextComponent(index, &looking))
{
// Need to add this to system component list
if (!ghSystemComponents) ghSystemComponents=NuHandle(0);
if (ghSystemComponents)
PtrAndHand(&index, (Handle)ghSystemComponents, sizeof(index));
}
}
while(index);
}
/**********************************************************************
* ETLDrain - how much memory do the plug-ins use?
**********************************************************************/
long ETLDrain(void)
{
return gPluginDrain;
}
/**********************************************************************
* Functions for individual modules
**********************************************************************/
ModeTypeEnum GetCurrentPayMode () {
if ( CanPayMode ()) return EMS_ModePaid;
if ( IsAdwareMode ()) return EMS_ModeSponsored;
if ( IsFreeMode ()) return EMS_ModeFree;
ASSERT ( false );
return EMS_ModeFree;
}
/**********************************************************************
* ETLInit - global translator initialization
**********************************************************************/
OSErr ETLInit()
{
short m, mCount;
short t;
short selItem=0,specItem=SPECIAL_BAR4_ITEM,attItem=0,setItem=0;
OSErr err = noErr;
Str255 s;
//Handle nHandle;
MenuHandle selMH = GetMHandle(TLATE_SEL_HIER_MENU);
MenuHandle setMH = GetMHandle(TLATE_SET_HIER_MENU);
MenuHandle specMH = GetMHandle(SPECIAL_MENU);
MenuHandle attMH = GetMHandle(TLATE_ATT_HIER_MENU);
TLMaster tlm;
TLFuncList tlfl;
Handle icon=nil;
//Boolean anIcon;
//short version;
Boolean menu;
Accumulator instances;
short realCount=0;
emsMIMEHandle tlMIME=nil;
OSErr looseErr;
struct emsMenuS emsMenuStuff;
emsPluginInfo pluginInfo;
gPluginDrain = 0;
if (TLSelList) {ETLAddAppleItem(); return(ETLAddVolatileMenus());}
TLSelList = NuHandle(0);
TLQ4List = NuHandle(0);
TLSpecialList = NuHandle(0);
TLAttachList = NuHandle(0);
TLSettingList = NuHandle(0);
TLModelessList = NuHandle(0);
TLImporterList = NuHandle(0);
TLFL = NuHandle(0);
Zero(instances);
NewMIME(&tlMIME,MIME_TEXT,MIME_PLAIN);
gTranslatorFlags = 0;
if (TLFL && TLModelessList && TLSelList && TLQ4List && TLSpecialList && TLAttachList && TLSettingList && TLImporterList &&
selMH && setMH && attMH && specMH && (mCount=ETLOpenModules(&instances)))
{
for (m=0;m<mCount;m++)
{
long drain,free,mem_rqmnt;
err = 0;
mem_rqmnt = 0;
free = FreeMem();
Zero(tlfl);
tlfl.instance = (*(ComponentInstance**)instances.data)[m];
#if defined(NEVER)
if (err = ems_plugin_version(tlfl.instance,&version))
{
// Older, version 1, plugin which doesn't have the version function. Version 3+ MUST implement the version function
version = 1;
err = 0;
}
#endif
tlfl.version = GetComponentVersion(tlfl.instance)>>16;
if (!err)
{
Zero(pluginInfo);
if (UseParameterBlockStyleFunctions(tlfl.version))
{
Zero(pluginInfo);
SetSize(pluginInfo);
if (UseOldMailConfig(tlfl.version))
{
emsPre7MailConfig mailConfig;
ETLFillMailConfig(&mailConfig, nil, true);
MightSwitch();
err = ems_plugin_init(tlfl.instance,EMS_VERSION,&mailConfig,&pluginInfo);
AfterSwitch();
ETLEmptyMailConfig(&mailConfig);
}
else
{
emsCallBack callbacks;
emsMailConfig mailConfig;
ETLFillMailConfig(&mailConfig, &callbacks, false);
MightSwitch();
err = ems_plugin_init(tlfl.instance,EMS_VERSION,&mailConfig,&pluginInfo);
AfterSwitch();
ETLEmptyMailConfig(&mailConfig);
}
tlfl.moduleDescription = pluginInfo.desc;
tlfl.moduleID = pluginInfo.id;
tlfl.moduleSuite = pluginInfo.icon;
tlfl.numMBoxContext = pluginInfo.numMBoxContext;
if (tlfl.idleTimeFreq = pluginInfo.idleTimeFreq)
{
tlfl.lastIdleTime = (TickCount()*50)/3; // (ticks / 60 * 1000) Roughly in milliseconds
gIdleTimeCount++;
}
tlfl.tCount = pluginInfo.numTrans;
mem_rqmnt = pluginInfo.mem_rqmnt;
}
else
{
MightSwitch();
err = tl_module_init(tlfl.instance,&tlfl.tCount,&tlfl.moduleDescription,&tlfl.moduleID,&tlfl.moduleSuite);
AfterSwitch();
}
}
// Make sure we get a name
if (!tlfl.moduleDescription)
{
ComponentDescription cd;
if (tlfl.moduleDescription = NuHandle(0))
{
GetComponentInfo(tlfl.instance,&cd,tlfl.moduleDescription,nil,nil);
if (!GetHandleSize(tlfl.moduleDescription)) ZapHandle(tlfl.moduleDescription);
}
}
// Ugly hack time
if (tlfl.moduleID==29 || tlfl.moduleID==31) tlfl.modeNeeded = EMS_ModePaid;
//if (!err && version!=TL_VERSION) ETLError(moduleDescription,ETL_BAD_VERSION,nil,version,0);
//else
if (err)
{
ETLError(tlfl.moduleDescription,ETL_CANT_INIT,nil,err,0);
UnregisterComponent(tlfl.instance);
}
else if (!(err = PtrPlusHand_(&tlfl,TLFL,sizeof(tlfl))))
{
if (ComponentFunctionImplemented(tlfl.instance,kems_plugin_configRtn))
{
tlm.menuItem = ++setItem;
tlm.module = realCount;
PtrPlusHand_(&tlm,TLSettingList,sizeof(tlm));
PCopy(s,*tlfl.moduleDescription);
PCat(s,"\p...");
MyAppendMenu(setMH,s);
}
// translators
for (t=0;t<tlfl.tCount;t++)
{
Zero(tlm);
// v3
if (UseParameterBlockStyleFunctions(tlfl.version))
{
emsTranslator transInfo;
Zero(transInfo);
SetSize(transInfo);
transInfo.id = t+1;
MightSwitch();
err = ems_translator_info(tlfl.instance,&transInfo);
AfterSwitch();
tlm.type = transInfo.type;
tlm.flags = transInfo.flags;
tlm.nameHandle = transInfo.desc;
tlm.suite = transInfo.icon;
}
// v1
else
{
MightSwitch();
err = tl_translator_info(tlfl.instance,t+1,&tlm.type,nil,&tlm.flags,&tlm.nameHandle,&tlm.suite);
AfterSwitch();
}
if (!err)
{
gTranslatorFlags |= tlm.flags;
menu = (tlm.flags & TLF_ON_REQUEST);
if (menu) tlm.menuItem = ++selItem;
tlm.module = realCount;
tlm.id = t+1;
err = PtrPlusHand_(&tlm,TLSelList,sizeof(tlm));
if (err) ZapHandle(tlm.nameHandle);
if (tlm.suite && (tlm.flags&(EMSF_Q4_TRANSMISSION)) &&
(tlm.flags&TLF_WHOLE_MESSAGE))
PtrPlusHand_(&tlm,TLQ4List,sizeof(tlm));
if (!ComponentFunctionImplemented(tlfl.instance,kems_plugwindow_closeRtn))
PtrPlusHand_(&tlm,TLModelessList,sizeof(tlm));
if (!LooseTrans)
{
looseErr = CanTranslateFile(&tlfl,TLF_ON_ARRIVAL,tlm.id,tlMIME,
nil,nil,nil,nil,nil);
LooseTrans = looseErr==TLR_NOW || looseErr==TLR_NOT_NOW;
}
}
}
// attachers
for (t=0;t<pluginInfo.numAttachers;t++)
{
Zero(emsMenuStuff); SetSize(emsMenuStuff);
emsMenuStuff.id = t;
if (!(err=!ComponentFunctionImplemented(tlfl.instance,kems_attacher_infoRtn)))
{
MightSwitch();
err=ems_attacher_info(tlfl.instance,&emsMenuStuff);
AfterSwitch();
if (!err)
{
if (emsMenuStuff.desc)
{
Zero(tlm);
tlm.id = t;
tlm.module = realCount;
tlm.menuItem = ++attItem;
tlm.nameHandle = emsMenuStuff.desc;
tlm.flags = emsMenuStuff.flags;
PtrPlusHand_(&tlm,TLAttachList,sizeof(tlm));
MyAppendMenu(attMH,PCopy(s,*tlm.nameHandle));
}
if (emsMenuStuff.icon)
DisposeIconSuite(emsMenuStuff.icon,true);
}
}
}
// specials
for (t=0;t<pluginInfo.numSpecials;t++)
{
Zero(emsMenuStuff); SetSize(emsMenuStuff);
emsMenuStuff.id = t;
if (!(err=!ComponentFunctionImplemented(tlfl.instance,kems_special_infoRtn)))
{
MightSwitch();
err=ems_special_info(tlfl.instance,&emsMenuStuff);
AfterSwitch();
if (!err)
{
if (emsMenuStuff.desc)
{
Zero(tlm);
tlm.id = t;
tlm.module = realCount;
tlm.menuItem = ++specItem;
tlm.nameHandle = emsMenuStuff.desc;
tlm.flags = emsMenuStuff.flags;
PtrPlusHand_(&tlm,TLSpecialList,sizeof(tlm));
}
if (emsMenuStuff.icon)
DisposeIconSuite(emsMenuStuff.icon,true);
}
}
}
// search for any importers
for (t=0;(t<pluginInfo.numImporters);t++)
{
emsImporter importerInfo;
Zero(importerInfo);
SetSize(importerInfo);
importerInfo.id = t+1;
if (!(err=!ComponentFunctionImplemented(tlfl.instance,kems_importer_infoRtn)))
{
MightSwitch();
err=ems_importer_info(tlfl.instance,&importerInfo);
AfterSwitch();
if (!err)
{
if (importerInfo.desc)
{
Zero(tlm);
tlm.id = t;
tlm.module = realCount;
tlm.nameHandle = importerInfo.desc;
tlm.flags = importerInfo.flags;
tlm.suite = importerInfo.icon;
PtrPlusHand_(&tlm,TLImporterList,sizeof(tlm));
}
gImportersAvailable = true; // remember that at least one importer has been found
}
}
}
err = 0;
realCount++;
}
// Calculate memory used by this plug-in. Use the greater of:
// 1) actualy memory used, 2) memory use as reported by the plug-in
drain = free - FreeMem();
gPluginDrain += drain>mem_rqmnt ? drain : mem_rqmnt;
}
// Notify all plugins that care of the current mode
ETLEudoraModeNotification(EMS_ModeChanged, GetCurrentPayMode ());
}
GetRString(s,NO_TRANSLATORS);
#define NO_TRANS(x) do{if (!x##Item) {MyAppendMenu(x##MH,s);SetItemStyle(x##MH,1,italic);DisableItem(x##MH,1);}}while(0)
NO_TRANS(sel);
NO_TRANS(att);
if (realCount) GetRString(s,NO_TRANSLATORS_WITH_SETTINGS);
NO_TRANS(set);
ETLAddVolatileMenus();
AccuZap(instances);
ZapTLMIME(tlMIME);
if (!realCount) {ZapHandle(TLFL);ZapHandle(TLSelList);ZapHandle(TLQ4List);ZapHandle(TLSpecialList);ZapHandle(TLAttachList);ZapHandle(TLImporterList);}
else ETLAddAppleItem();
return(realCount ? noErr : fnfErr);
}
/************************************************************************
* ETLAddToToolbar - add any translators, attachers or special items
* to the toolbar that are requesting it
************************************************************************/
static void CheckAddToToolbar(TLMHandle hTLM, MenuHandle hMenu)
{
short i,n;
Str255 s;
short oldRefN = CurResFile();
typedef struct TLMaster
{
short moduleID;
short menuID;
Str32 itemText;
} TBIconList, *TBIconListPtr, **TBIconListHandle;
if (hMenu && hTLM && *hTLM && (n=HandleCount(hTLM)))
{
for (i=0;i<n;i++)
{
if ((*hTLM)[i].flags & EMSF_TOOLBAR_PRESENCE)
{
// Put this arrogant translator in the toolbar
Boolean doAdd;
TBIconListHandle hAddedList;
TBIconListPtr pAddedList;
short menuID = GetMenuID(hMenu);
short moduleID = (*TLFL)[(*hTLM)[i].module].moduleID;
// Make sure we haven't added it before
doAdd = true;
PCopy(s,*(*hTLM)[i].nameHandle);
if (*s>31) *s=31;
UseResFile(SettingsRefN);
if (hAddedList = (TBIconListHandle)Get1Resource(TOOLBAR_ICON_RTYPE,TOOLBAR_ICON_ID))
{
short count;
for(pAddedList=*hAddedList,count=HandleCount(hAddedList);count--;pAddedList++)
{
if (pAddedList->moduleID==moduleID && pAddedList->menuID==menuID && StringSame(pAddedList->itemText,s))
{
// We've previously added this one. Once is enough!
doAdd = false;
break;
}
}
}
if (doAdd && TBAddMenuButton(menuID,(*hTLM)[i].menuItem,s))
{
TBIconList iconListItem;
// Add to list of items already added
Zero(iconListItem);
iconListItem.moduleID = moduleID;
iconListItem.menuID = menuID;
PCopy(iconListItem.itemText,s);
if (!hAddedList)
{
// Need to create new resource
hAddedList = NuHandle(0);
AddResource_(hAddedList,TOOLBAR_ICON_RTYPE,TOOLBAR_ICON_ID,"");
}
PtrAndHand(&iconListItem,(Handle)hAddedList,sizeof(iconListItem));
ChangedResource((Handle)hAddedList);
}
}
}
}
UseResFile(oldRefN);
}
/************************************************************************
* ETLAddToToolbar - add any translators, attachers or special items
* to the toolbar that are requesting it
************************************************************************/
void ETLAddToToolbar(void)
{
CheckAddToToolbar(TLSelList,GetMHandle(TLATE_SEL_HIER_MENU));
CheckAddToToolbar(TLAttachList,GetMHandle(TLATE_ATT_HIER_MENU));
CheckAddToToolbar(TLSpecialList,GetMHandle(SPECIAL_MENU));
}
/************************************************************************
* ETLAddVolatileMenus - add trans items to menus that need to be refreshed
* when switching settings files
************************************************************************/
OSErr ETLAddVolatileMenus(void)
{
MenuHandle specMH = GetMHandle(SPECIAL_MENU);
MenuHandle selMH = GetMHandle(TLATE_SEL_HIER_MENU);
short i,n;
Str255 s;
if (specMH && TLSpecialList && *TLSpecialList && (n=HandleCount(TLSpecialList)))
{
AppendMenu(specMH,"\p-");
for (i=0;i<n;i++)
MyAppendMenu(specMH,PCopy(s,*(*TLSpecialList)[i].nameHandle));
}
if (selMH && TLSelList && *TLSelList && (n=HandleCount(TLSelList)))
{
for (i=0;i<n;i++)
if ((*TLSelList)[i].flags & TLF_ON_REQUEST)
MyAppendMenu(selMH,PCopy(s,*(*TLSelList)[i].nameHandle));
}
return(noErr);
}
/************************************************************************
* ETLFillMailConfig - fill a mailconfig
************************************************************************/
void ETLFillMailConfig(emsMailConfigP mailConfig, emsCallBacksP callBacks, Boolean useOldMailConfig)
{
Str255 scratch;
// Account for differences between old and new mail config structures
if (useOldMailConfig)
{
emsPre7MailConfigP oldMailConfig = (emsPre7MailConfigP) mailConfig;
Zero(*oldMailConfig);
SetSize(*oldMailConfig);
// Old mail config structure accidently had callbacks directly in the structure
callBacks = &oldMailConfig->callBacks;
}
else
{
Zero(*mailConfig);
SetSize(*mailConfig);
// New mail config structure has pointer to callbacks so that we can have fields
// after the callbacks.
mailConfig->callBacks = callBacks;
// For a while we had eudAPIMinorVersion in the old structure, but the location became
// obsolete as more callbacks were added. Now we only support it in the new structure.
mailConfig->eudAPIMinorVersion = EMS_MINOR_VERSION;
}
// From here on out we've already accounted for all the differences
FSMakeFSSpec(ItemsFolder.vRef,ItemsFolder.dirId,GetRString(scratch,PLUGINS_FOLDER),&mailConfig->configDir);
SetSize(mailConfig->userAddr);
mailConfig->userAddr.address = NewString(GetReturnAddr(scratch,false));
mailConfig->userAddr.realname = NewString(GetRealname(scratch));
// v4 stuff
callBacks->EMSGetMailBoxFunction = TO_UPP_OR_NOT_TO_UPP(ETLGetMailbox);
callBacks->EMSSetMailBoxTagFunction = TO_UPP_OR_NOT_TO_UPP(ETLSetMailBoxTag);
callBacks->EMSGetPersonalityFunction = TO_UPP_OR_NOT_TO_UPP(ETLGetPersonality);
callBacks->EMSProgressFunction = TO_UPP_OR_NOT_TO_UPP(ETLProgress3);
callBacks->EMSRegenerateFunction = TO_UPP_OR_NOT_TO_UPP(ETLRegenerate);
callBacks->EMSGetDirectoryFunction = TO_UPP_OR_NOT_TO_UPP(ETLGetDirectory);
callBacks->EMSUpdateWindowsFunction = TO_UPP_OR_NOT_TO_UPP(ETLUpdateWindows);
// v5 stuff
callBacks->EMSGetMailBoxTagFunction = TO_UPP_OR_NOT_TO_UPP(ETLGetMailBoxTag);
callBacks->EMSGetPersonalityInfoFunction = TO_UPP_OR_NOT_TO_UPP(ETLGetPersonalityInfo);
callBacks->EMSPlugwindowRegisterFunction = TO_UPP_OR_NOT_TO_UPP(ETLPlugwindowRegister);
callBacks->EMSPlugwindowUnRegisterFunction = TO_UPP_OR_NOT_TO_UPP(ETLPlugwindowUnRegister);
callBacks->EMSGDeviceRgnFunction = TO_UPP_OR_NOT_TO_UPP(ETLGDeviceRgn);
callBacks->EMSFrontWindowFunction = TO_UPP_OR_NOT_TO_UPP(ETLFrontWindow);
callBacks->EMSSelectWindowFunction = TO_UPP_OR_NOT_TO_UPP(ETLSelectWindow);
// v6 stuff
callBacks->EMSMakeSigFunction = TO_UPP_OR_NOT_TO_UPP(ETLMakeSig);
callBacks->EMSMakeAddressBookFunction = TO_UPP_OR_NOT_TO_UPP(ETLMakeAddressBook);
callBacks->EMSMakeABEntryFunction = TO_UPP_OR_NOT_TO_UPP(ETLMakeABEntry);
callBacks->EMSMakeMailboxFunction = TO_UPP_OR_NOT_TO_UPP(ETLMakeMailbox);
callBacks->EMSMakeOutMessFunction = TO_UPP_OR_NOT_TO_UPP(ETLMakeOutMess);
callBacks->EMSMakeMessageFunction = TO_UPP_OR_NOT_TO_UPP(ETLMakeMessage);
callBacks->EMSCreateMailBoxFunction = TO_UPP_OR_NOT_TO_UPP(ETLCreateMailBox);
// v7 stuff
callBacks->EMSIsInAddressBook = TO_UPP_OR_NOT_TO_UPP(ETLIsInAddressBook);
}
/************************************************************************
* ETLEmptyMailConfig - empty the mailconfig
************************************************************************/
void ETLEmptyMailConfig(emsMailConfigP mailConfig)
{
ZapHandle(mailConfig->userAddr.address);
ZapHandle(mailConfig->userAddr.realname);
}
/**********************************************************************
*
**********************************************************************/
void ETLAddAppleItem(void)
{
Str255 s;
MenuHandle mh = GetMHandle(APPLE_MENU);
InsertMenuItem(mh,GetRString(s,ABOUT_TRANSLATORS),1);
}
/**********************************************************************
*
**********************************************************************/
Boolean ETLExists(void)
{
return(TLFL!=nil);
}
/**********************************************************************
* ETLDoAbout - give Laurence his darn about translators window
**********************************************************************/
void ETLDoAbout(void)
{
short n = HandleCount(TLFL);
MyWindowPtr win;
WindowPtr winWP;
ControlHandle cntl;
ListHandle list;
Rect r,bounds;
Point c;
DECLARE_UPP(TlateListDef,ListDef);
INIT_UPP(TlateListDef,ListDef);
if (ModalWindow) return; // already a window onscreen
if (win=GetNewMyWindow(ETL_ABOUT_WIND,nil,nil,nil,False,False,ETL_ABOUT_WIN))
{
winWP = GetMyWindowWindowPtr (win);
win->position = PositionPrefsTitle;
win->isRunt = True;
win->button = ETLAboutButton;
win->update = ETLAboutUpdate;
win->close = ETLAboutClose;
win->click = ETLAboutClick;
win->key = ETLKey;
win->dontControl = True;
MySetThemeWindowBackground(win,kThemeListViewBackgroundBrush,False);
SetRect(&r,2*INSET,2*INSET,win->contR.right-INSET-GROW_SIZE,win->contR.bottom-20-3*INSET);
SetRect(&bounds,0,0,1,n);
c.v = 38;
c.h = RectWi(r);
if (!(list = CreateNewList(TlateListDefUPP,TLATE_LDEF,&r,&bounds,c,winWP,True,False,False,True)))
CloseMyWindow(winWP);
else
{
(*list)->indent.h = INSET;
cntl = GetNewControl(ETL_OK_CNTL,winWP);
SetControlReference(cntl,'OKbn');
if (!cntl) CloseMyWindow(winWP);
else
{
MoveMyCntl(cntl,win->contR.right-INSET-ControlWi(cntl),
win->contR.bottom-INSET-ControlHi(cntl),0,0);
SetMyWindowPrivateData (win,(long)list);
ShowMyWindow(winWP);
PushModalWindow(winWP);
}
}
}
}
/**********************************************************************
* ETLAboutClick - handle clicks
**********************************************************************/
void ETLAboutClick(MyWindowPtr win, EventRecord *event)
{
Point mouse = event->where;
Rect listR = (*(ListHandle)GetMyWindowPrivateData(win))->rView;
GlobalToLocal(&mouse);
listR.right += GROW_SIZE;
if (PtInRect(mouse,&listR)) LClick(mouse,event->modifiers,(ListHandle)GetMyWindowPrivateData(win));
else HandleControl(mouse,win);
}
/**********************************************************************
* ETLAboutButton - shows button
**********************************************************************/
void ETLAboutButton(MyWindowPtr win,ControlHandle button,long modifiers,short part)
{
#pragma unused(button)
WindowPtr winWP = GetMyWindowWindowPtr (win);
if (part==kControlButtonPart) CloseMyWindow(winWP);
AuditHit((modifiers&shiftKey)!=0, (modifiers&controlKey)!=0, (modifiers&optionKey)!=0, (modifiers&cmdKey)!=0, false, GetWindowKind(winWP), AUDITCONTROLID(GetWindowKind(winWP),kControlButtonPart), mouseDown);
}
/**********************************************************************
* ETLAboutClose - close the window
**********************************************************************/
Boolean ETLAboutClose(MyWindowPtr win)
{
if (GetMyWindowPrivateData(win))
{
LDispose((ListHandle)GetMyWindowPrivateData(win));
SetMyWindowPrivateData(win, 0);
}
return(True);
}
/**********************************************************************
*
**********************************************************************/
Boolean ETLKey(MyWindowPtr win, EventRecord *event)
{
#pragma unused(event)
short c = (event->message & charCodeMask);
if (c==enterChar || c==returnChar || c==escChar) CloseMyWindow(GetMyWindowWindowPtr(win));
return(True);
}
/**********************************************************************
* ETLAboutUpdate - update the window
**********************************************************************/
void ETLAboutUpdate(MyWindowPtr win)
{
WindowPtr winWP = GetMyWindowWindowPtr(win);
Rect r;
ControlHandle cntl = FindControlByRefCon(win,'OKbn');
if (GetMyWindowPrivateData(win))
{
r = (*(ListHandle)GetMyWindowPrivateData(win))->rView;
r.right += GROW_SIZE;
DrawThemeListBoxFrame(&r,kThemeStateActive);
LUpdate(MyGetPortVisibleRegion(GetWindowPort(winWP)),(ListHandle)GetMyWindowPrivateData(win));
if (cntl)
OutlineControl(cntl,True);
}
}
/**********************************************************************
* ETLMenu2Icon - get icon suite for plug-in menu selection
**********************************************************************/
Handle ETLMenu2Icon(short menu,short item)
{
short n;
TLMaster tlm;
Handle suite = nil;
Boolean gotModule = false;
emsMenu emsMenuStuff;
OSErr err;
switch (menu)
{
case TLATE_SEL_HIER_MENU:
for(n=HandleCount(TLSelList);n--;)
if ((*TLSelList)[n].menuItem==item)
{
tlm = (*TLSelList)[n];
GetTransIcon(&(*TLFL)[tlm.module],tlm.id,&suite);
gotModule = true;
break;
}
break;
case SPECIAL_MENU:
case TLATE_ATT_HIER_MENU:
if (menu == SPECIAL_MENU)
{
if (item>SPECIAL_BAR4_ITEM)
{
tlm = (*TLSpecialList)[item-SPECIAL_BAR4_ITEM-1];
gotModule = true;
}
}
else
{
tlm = (*TLAttachList)[item-1];
gotModule = true;
}
if (gotModule)
{
Zero(emsMenuStuff); SetSize(emsMenuStuff);
emsMenuStuff.id = tlm.id;
MightSwitch();
if (menu == SPECIAL_MENU)
err=ems_special_info((*TLFL)[tlm.module].instance,&emsMenuStuff);
else
err=ems_attacher_info((*TLFL)[tlm.module].instance,&emsMenuStuff);
AfterSwitch();
if (!err)
{
suite = emsMenuStuff.icon;
if (emsMenuStuff.desc)
DisposeHandle((Handle)emsMenuStuff.desc);
}
}
break;
}
if (gotModule && !suite)
{
Handle moduleSuite;
// Use module's icon
if (moduleSuite = (*TLFL)[tlm.module].moduleSuite)
DupIconSuite(moduleSuite,&suite,false);
}
return suite;
}
/**********************************************************************
* ETLListAllTranslators - list all the translators appropriate to a given context
* translators - pointer to handle to translator list; will be allocated
* context - the translator context (eg, tlOnArrival)
* Returns:
* TLR_CANT_TRANS - no translators for current context
* noErr - found at least one translator
**********************************************************************/
OSErr ETLListAllTranslatorsLo(TLMHandle *translators, short context, ModeTypeEnum forMode)
{
short i, n;
if (!TLSelList) return(TLR_CANT_TRANS);
n = HandleCount(TLSelList);
*translators = (TLMHandle)NuHTempBetter((n+1)*sizeof(TLMaster));
if (!*translators) return(MemError());
n = 0;
for (i=HandleCount(TLSelList);i--;)
if (((*TLSelList)[i].flags & context) && (*TLFL)[(*TLSelList)[i].module].modeNeeded<=forMode)
{
(**translators)[n] = (*TLSelList)[i];
n++;
}
if (!n)
{
ZapHandle(*translators);
return(TLR_CANT_TRANS);
}
else
{
SetHandleBig_(*translators,(n+1)*sizeof(TLMaster));
(**translators)[n].module = REAL_BIG;
(**translators)[n].result = REAL_BIG;
return(noErr);
}
}
/************************************************************************
* ETLCountTranslators - count the translators that work in a context & current mode
************************************************************************/
OSErr ETLCountTranslatorsLo(short context,ModeTypeEnum forMode)
{
TLMHandle tList = nil;
short count = 0;
(void) ETLListAllTranslatorsLo ( &tList, context, forMode );
if (tList)
{
count = HandleCount(tList)-1;
count = MAX(count,0);
ZapHandle(tList);
}
return count;
}
/**********************************************************************
* ETLRemoveDeadTranslators - remove translators that have been used or
* will never be used
* translators - handle to list of translators
* Returns:
* TLR_CANT_TRANS - if no live translators remain
**********************************************************************/
OSErr ETLRemoveDeadTranslators(TLMHandle translators)
{
short n = HandleCount(translators);
short from, to;
for (from=to=0;from<n;from++)
switch((*translators)[from].result)
{
case TLR_NOT_NOW:
case TLR_NOW:
if (to!=from) (*translators)[to] = (*translators)[from];
to++;
break;
}
if (to<n) SetHandleBig_(translators,to*sizeof(TLMaster));
return to > 0 ? noErr : TLR_CANT_TRANS;
}
/**********************************************************************
* ETLSortTranslators - sort translators by module and group
* translators - handle to translator list to sort
**********************************************************************/
void ETLSortTranslators(TLMHandle translators)
{
short n = HandleCount(translators);
QuickSort((void*)LDRef(translators),sizeof(TLMaster),0,n-2,(void*)ETLCompare,(void*)ETLSwap);
UL(translators);
}
/**********************************************************************
* ETLCompare - compare two translators
**********************************************************************/
int ETLCompare(TLMPtr t1,TLMPtr t2)
{
long diff;
if (diff=(t1->result-t2->result)) return(diff);
if (diff=(t1->type-t2->type)) return(diff);
if (diff=(t1->module-t2->module)) return(diff);
return(0);
}
/**********************************************************************
* ETLSwap - swap two translators
**********************************************************************/
void ETLSwap(TLMPtr t1,TLMPtr t2)
{
TLMaster t;
t = *t1;
*t1 = *t2;
*t2 = t;
}
/**********************************************************************
* ETLListRequestedTranslators - make a translator list from the messages
**********************************************************************/
OSErr ETLListRequestedTranslators(TLMHandle *translators, TransInfoHandle hRequested)
{
short i, n, index;
//Boolean canDo;
short nReq;
if (!TLSelList && !hRequested) return(TLR_CANT_TRANS);
nReq = HandleCount(hRequested);
*translators = (TLMHandle)NuHTempBetter((nReq+1)*sizeof(TLMaster));
if (!*translators) return(MemError());
n = 0;
for (i=0;i<nReq;i++)
{
index = ETLIDToIndex((*hRequested)[i].id);
if (index<0)
{
WarnUser(ETL_CANT_FIND_TRANS,0);
n = 0;
break;
}
(**translators)[n] = (*TLQ4List)[index];
n++;
}
if (!n)
{
ZapHandle(*translators);
return(TLR_CANT_TRANS);
}
else
{
SetHandleBig_(*translators,(n+1)*sizeof(TLMaster));
(**translators)[n].module = REAL_BIG;
(**translators)[n].result = REAL_BIG;
ETLSortTranslators(*translators);
for (i=0;i<n-1;i++)
{
if ((**translators)[i].type==TLT_SIGNATURE && (**translators)[i+1].type==TLT_PREPROCESS)
{
short bigI = HandleCount(TLSelList);
while (bigI--)
{
if ((*TLSelList)[bigI].module==(**translators)[i].module &&
(*TLSelList)[bigI].type==TLT_COALESCED)
{
(**translators)[i] = (*TLSelList)[bigI];
for (i++;i<n;i++) (**translators)[i] = (**translators)[i+1];
SetHandleBig_(*translators,n*sizeof(TLMaster));
return(noErr);
}
}
}
}
return(noErr);
}
}
/**********************************************************************
* ETLOutputHandle - output a handle to a file or accumulator (or nowhere)
**********************************************************************/
OSErr ETLOutputHandle(UHandle text,short refN,AccuPtr a)
{
OSErr err=noErr;
if (refN)
{
long size = GetHandleSize(text);
err = AWrite(refN,&size,LDRef(text));
UL(text);
}
else if (a) err = AccuAddHandle(a,text);
return(err);
}
/**********************************************************************
* ETLOutputPtr - output a pointer to a file or accumulator (or nowhere)
**********************************************************************/
OSErr ETLOutputPtr(UPtr text,long size,short refN,AccuPtr a)
{
OSErr err = noErr;
long locSize = size;
if (refN) err = AWrite(refN,&locSize,text);
else if (a) err = AccuAddPtr(a,text,size);
return(err);
}
/**********************************************************************
* progress callbacks
**********************************************************************/
// support ems api 1.0
static pascal short ETLProgress(short percent)
{
PushGWorld();
SetPort_(InsurancePort);
CycleBalls();
if (percent!=-1) Progress(percent,NoChange,nil,nil,nil);
PopGWorld();
return(CommandPeriod);
}
// support ems api 3.0
static pascal short ETLProgress3(emsProgressDataP progData)
{
short percent = -1;
PStr message = nil;
if (progData) {
percent = progData->value;
message = progData->message;
}
PushGWorld();
SetPort_(InsurancePort);
CycleBalls();
if (percent!=-1) Progress(percent,NoChange,nil,nil,message);
PopGWorld();
return(CommandPeriod);
}
/**********************************************************************
* ETLGetMailbox - allow user to select a mailbox
**********************************************************************/
static pascal void ETLGetMailbox(emsGetMailBoxDataP pData)
{
FSSpec spec;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
pData->mailbox = nil;
if (ChooseMailboxLo(MAILBOX_MENU,pData->prompt,&spec,!(pData->flags&EMSFGETMBOX_ALLOW_NEW),!(pData->flags&EMSFGETMBOX_ALLOW_OTHER),(pData->flags&EMSFGETMBOX_DISALLOW_NON_LOCAL)))
{
// Return alias to mailbox
FSSpec mailFolderSpec;
// Alias is relative to mail folder
FSMakeFSSpec(MailRoot.vRef, MailRoot.dirId, "", &mailFolderSpec);
NewAlias(&mailFolderSpec, &spec, &pData->mailbox);
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
}
/**********************************************************************
* ETLGetMailBoxTag - get tag ID for a mailbox
**********************************************************************/
static pascal void ETLGetMailBoxTag(emsSetMailBoxTagDataP pData)
{
FSSpec spec,mailFolderSpec;
TOCHandle tocH;
Boolean wasChanged;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
pData->oldkey = pData->oldvalue = 0;
// Alias is relative to mail folder
FSMakeFSSpec(MailRoot.vRef, MailRoot.dirId, "", &mailFolderSpec);
if (!ResolveAlias(&mailFolderSpec, pData->mailbox, &spec, &wasChanged))
{
// get key from mailbox's TOC
if (!GetTOCByFSS(&spec,&tocH))
{
pData->oldkey = (*tocH)->pluginKey;
pData->oldvalue = (*tocH)->pluginValue;
}
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
}
/**********************************************************************
* ETLSetMailBoxTag - set tag ID for a mailbox
**********************************************************************/
static pascal void ETLSetMailBoxTag(emsSetMailBoxTagDataP pData)
{
FSSpec spec,mailFolderSpec;
TOCHandle tocH;
Boolean wasChanged;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
// Alias is relative to mail folder
FSMakeFSSpec(MailRoot.vRef, MailRoot.dirId, "", &mailFolderSpec);
if (!ResolveAlias(&mailFolderSpec, pData->mailbox, &spec, &wasChanged))
{
// Add key to mailbox's TOC
if (!GetTOCByFSS(&spec,&tocH))
{
if (pData->size>=sizeof(*pData))
pData->oldkey = (*tocH)->pluginKey;
(*tocH)->pluginKey = pData->key;
pData->oldvalue = (*tocH)->pluginValue;
(*tocH)->pluginValue = pData->value;
TOCSetDirty(tocH,true);
if ((*tocH)->win)
{
Rect rOldSize;
GetPortBounds(GetMyWindowCGrafPtr((*tocH)->win),&rOldSize);
MyWindowDidResize((*tocH)->win,&rOldSize);
}
}
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
}
/************************************************************************
* ETLPlugwindowRegister - tell Eudora that a window belongs to a plug-in
************************************************************************/
pascal short ETLPlugwindowRegister(emsPlugwindowDataP wd)
{
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
{
WindowPtr theWindow = wd->nativeWindow;
emsPlugwindowDataH wdh = NewH(emsPlugwindowData);
if (!wdh) return(MemError());
**wdh = *wd;
SetWRefCon(theWindow,(long)wdh);
SetWindowKind(theWindow,EMS_PW_WINDOWKIND);
if (IsModalPlugwindow(theWindow))
PushModalWindow(theWindow);
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return(noErr);
}
/************************************************************************
* ETLPlugwindowUnRegister - tell Eudora that a window is dying
************************************************************************/
pascal void ETLPlugwindowUnRegister(emsPlugwindowDataP wd)
{
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
{
WindowPtr theWindow = wd->nativeWindow;
Handle theHandle = (Handle) GetWRefCon (theWindow);
if (theHandle != nil)
{
// Double check before calling PopModalWindow so that we're
// not at the mercy of a broken plugin.
if (IsModalPlugwindow(theWindow) && (theWindow == ModalWindow))
PopModalWindow();
ZapHandle(theHandle);
SetWRefCon(theWindow,nil);
}
#ifdef FLOAT_WIN
if (theWindow == lastHilitedWinWP) lastHilitedWinWP = 0;
#endif //FLOAT_WIN
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
}
/************************************************************************
* ETLGDeviceRgn - give plug-in device rgn
************************************************************************/
pascal void ETLGDeviceRgn(emsGDeviceRgnDataP gdr)
{
GDHandle gd;
Rect r;
Boolean hasMB = true;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
GetQDGlobalsScreenBitsBounds(&r);
utl_GetIndGD(gdr->gdIndex, &gd, &r, &hasMB);
InsetRect(&r,2,4);
r.left += GetRLong(DESK_LEFT_STRIP);
r.right -= GetRLong(DESK_RIGHT_STRIP);
r.bottom -= GetRLong(DESK_BOTTOM_STRIP);
r.top += GetRLong(DESK_TOP_STRIP);
if (hasMB)
r.top += utl_GetMBarHeight();
RectRgn(gdr->usableRgn,&r);
gdr->largestRectangle = r;
if (ToolbarSect(&r))
{
ToolbarReduce(&r);
gdr->largestRectangle = r;
ToolbarRect(&r);
RgnMinusRect(gdr->usableRgn,&r);
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
}
/**********************************************************************
* ETLFrontWindow - return the front window as Eudora thinks of it
**********************************************************************/
pascal WindowPtr ETLFrontWindow(void)
{
return MyFrontNonFloatingWindow();
}
/**********************************************************************
* ETLSelectWindow - SelectWindow our way
**********************************************************************/
pascal void ETLSelectWindow(WindowPtr wp)
{
if (wp) SelectWindow_(wp);
}
/**********************************************************************
* GetContextIconRect - get rect of context menu icon
**********************************************************************/
static void GetContextIconRect(Rect *rContentBox, Rect *rIcon)
{
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
*rIcon = *rContentBox;
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
}
/**********************************************************************
* PluginIDToIndex - find plug-in by module id
**********************************************************************/
static Boolean PluginIDToIndex(long key,short *index)
{
short i;
if (TLFL && key)
{
for (i=HandleCount(TLFL);i--;)
{
if ((*TLFL)[i].moduleID==key)
{
*index = i;
return true;
}
}
}
return false;
}
/**********************************************************************
* ETLDrawBoxTag - draw context menu if mailbox has plug-in tag
**********************************************************************/
void ETLDrawBoxTag(TOCHandle tocH,Rect *r)
{
short idx;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
if (PluginIDToIndex((*tocH)->pluginKey,&idx))
{
Rect rIcon;
IconTransformType transform = ttNone;
MyWindowPtr win = (*tocH)->win;
GetContextIconRect(r, &rIcon);
//FrameRect(&rIcon);
if (win && !win->isActive) transform = ttDisabled;
PlotIconSuite(&rIcon,atNone,transform,(*TLFL)[idx].moduleSuite);
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
}
/**********************************************************************
* ETLBoxTagWidth - return width of context menu icon
**********************************************************************/
short ETLBoxTagWidth(MyWindowPtr win)
{
short width = 0;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
{
TOCHandle tocH = (TOCHandle) GetMyWindowPrivateData(win);
if (tocH && (*tocH)->pluginKey)
width = 16;
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return width;
}
/**********************************************************************
* ETLAddBoxButtons - add the buttons to a peanut mailbox
**********************************************************************/
void ETLAddBoxButtons(TOCHandle tocH)
{
WindowPtr winWP = GetMyWindowWindowPtr((*tocH)->win);
short idx;
short item;
if (PluginIDToIndex((*tocH)->pluginKey,&idx) && (*tocH)->win->topMarginCntl)
{
tlInstance instance = (*TLFL)[idx].instance;
emsMenu menuInfo;
Str63 title;
ControlHandle cntl;
Rect r;
SetRect(&r,-200,-200,50-200,13-200);
for(item=1;item<=(*TLFL)[idx].numMBoxContext;item++)
{
SetSize(menuInfo);
menuInfo.id = item;
menuInfo.desc = nil;
MightSwitch();
ems_mbox_context_info(instance,&menuInfo);
AfterSwitch();
PCopy(title,(*menuInfo.desc));
ZapHandle(menuInfo.desc);
cntl = NewControlSmall(winWP,&r,title,true,0,0,0,0,'plug'+item);
EmbedControl(cntl,(*tocH)->win->topMarginCntl);
ButtonFit(cntl);
}
}
}
/**********************************************************************
* ETLButtonHit - the user clicked a plug-in button
**********************************************************************/
void ETLButtonHit(MyWindowPtr win,short item)
{
WindowPtr winWP = GetMyWindowWindowPtr(win);
TOCHandle tocH = (TOCHandle)GetMyWindowPrivateData(win);
short idx;
if (tocH && PluginIDToIndex((*tocH)->pluginKey,&idx))
{
tlInstance instance = (*TLFL)[idx].instance;
emsMenu menuInfo;
FSSpec mailFolderSpec,spec;
AliasHandle mailbox=nil;
spec = GetMailboxSpec(tocH,-1);
FSMakeFSSpec(MailRoot.vRef, MailRoot.dirId, "", &mailFolderSpec);
NewAlias(&mailFolderSpec, &spec, &mailbox);
SetSize(menuInfo);
menuInfo.id = item;
menuInfo.desc = nil;
MightSwitch();
ems_mbox_context_hook(instance,mailbox,&menuInfo);
AfterSwitch();
ZapHandle(mailbox);
AuditHit(false, false, false, false, false, GetWindowKind(winWP), AUDITCONTROLID(GetWindowKind(winWP),ETL_CONTEXT_POPUP_MENU), mouseDown);
}
}
#if 0 // Not used anymore
/**********************************************************************
* ETLClickContextMenu - check for click in plug-in context menu
**********************************************************************/
Boolean ETLClickContextMenu(MyWindowPtr win,Point pt,Rect *rContentBox)
{
WindowPtr winWP = GetMyWindowWindowPtr(win);
Rect rIcon;
Boolean wasContextMenu = false;
TOCHandle tocH;
short idx;
Str255 s;
GetContextIconRect(rContentBox, &rIcon);
if (PtInRect(pt,&rIcon) &&
(tocH = (TOCHandle)GetMyWindowPrivateData(win)) &&
PluginIDToIndex((*tocH)->pluginKey,&idx))
{
// Click on context menu icon
tlInstance instance = (*TLFL)[idx].instance;
MenuHandle mh = NewMenu(ETL_CONTEXT_POPUP_MENU,"");
if (mh)
{
emsMenu menuInfo;
short item,sel;
InsertMenu(mh,-1);
MightSwitch();
for(item=1;item<=(*TLFL)[idx].numMBoxContext;item++)
{
SetSize(menuInfo);
menuInfo.id = item;
menuInfo.desc = nil;
ems_mbox_context_info(instance,&menuInfo);
MyAppendMenu(mh,PCopy(s,(*menuInfo.desc)));
}
AfterSwitch();
pt.v = rIcon.top; // Display menu at top/right of icon
pt.h = rIcon.right; // Display menu at top/right of icon
LocalToGlobal(&pt);
if (sel = AFPopUpMenuSelect(mh,pt.v,pt.h-2*MenuWidth(mh)/3,0))
{
FSSpec mailFolderSpec,spec;
AliasHandle mailbox=nil;
spec = GetMailboxSpec(tocH,-1);
FSMakeFSSpec(MailRoot.vRef, MailRoot.dirId, "", &mailFolderSpec);
NewAlias(&mailFolderSpec, &spec, &mailbox);
SetSize(menuInfo);
menuInfo.id = sel;
menuInfo.desc = nil;
MightSwitch();
ems_mbox_context_hook(instance,mailbox,&menuInfo);
AfterSwitch();
ZapHandle(mailbox);
}
DeleteMenu(GetMenuID(mh));
DisposeMenu(mh);
}
wasContextMenu = true;
AuditHit(false, false, false, false, false, GetWindowKind(winWP), AUDITCONTROLID(GetWindowKind(winWP),ETL_CONTEXT_POPUP_MENU), mouseDown);
}
return wasContextMenu;
}
#endif
/**********************************************************************
* ETLHasMBoxContextFolder - Does the plugin have ems_mbox_context_folder?
**********************************************************************/
Boolean ETLHasMBoxContextFolder(MyWindowPtr win)
{
TOCHandle tocH = (TOCHandle) GetMyWindowPrivateData(win);
short idx;
return ( tocH && (*tocH)->pluginKey && PluginIDToIndex((*tocH)->pluginKey, &idx) &&
ComponentFunctionImplemented((*TLFL)[idx].instance, kems_mbox_context_folderRtn) );
}
/**********************************************************************
* ETLMBoxContextFolder - Get the plugin folder, if any
**********************************************************************/
short ETLMBoxContextFolder(MyWindowPtr win, short * vRefNum, long * dirID)
{
short result = EMSR_UNKNOWN_FAIL;
TOCHandle tocH = (TOCHandle) GetMyWindowPrivateData(win);
short idx;
if ( tocH && (*tocH)->pluginKey && PluginIDToIndex((*tocH)->pluginKey, &idx) )
{
tlInstance instance = (*TLFL)[idx].instance;
if ( ComponentFunctionImplemented(instance, kems_mbox_context_folderRtn) )
{
emsMailBoxContextFolderData contextFolderData;
Zero(contextFolderData);
SetSize(contextFolderData);
contextFolderData.value = (*tocH)->pluginValue;
result = ems_mbox_context_folder(instance, &contextFolderData);
if (vRefNum)
*vRefNum = contextFolderData.pluginFolder.vRefNum;
if (dirID)
*dirID = SpecDirId(&contextFolderData.pluginFolder);
}
}
return result;
}
/**********************************************************************
* ETLGetPersonality - allow user to select a personality
**********************************************************************/
static pascal short ETLGetPersonality(emsGetPersonalityDataP pData)
{
short result = EMSR_OK;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
{
Str255 scratch;
PersHandle oldCur = CurPers;
long oldSize = pData->size;
Zero(pData->personality);
SetSize(pData->personality);
if (CurPers = pData->defaultPers ? PersList : PersChoose(pData->prompt))
{
// Return address info from personality
GetReturnAddr(scratch,false);
if (scratch[*scratch]=='>') --*scratch;
if (*scratch && scratch[1]=='<')
{
--*scratch;
BMD(scratch+2,scratch+1,*scratch);
}
pData->personality.address = NewString(scratch);
pData->personality.realname = NewString(GetPref(scratch,PREF_REALNAME));
pData->persCount = PersCount();
if (oldSize>(char*)&pData->personalityName-(char*)pData)
pData->personalityName = NewString(PCopy(scratch,(*CurPers)->name));
}
else
result = EMSR_USER_CANCELLED;
CurPers = oldCur;
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return result;
}
/**********************************************************************
* ETLGetPersonalityInfo - allow user to select a personality
**********************************************************************/
static pascal short ETLGetPersonalityInfo(emsGetPersonalityInfoDataP pData)
{
short result = EMSR_OK;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
{
Str255 scratch;
PersHandle oldCur = CurPers;
long oldSize = pData->size;
Zero(pData->personality);
SetSize(pData->personality);
PCopy(scratch,*pData->personalityName);
if (CurPers = FindPersByName(scratch))
{
// Return address info from personality
GetReturnAddr(scratch,false);
if (scratch[*scratch]=='>') --*scratch;
if (*scratch && scratch[1]=='<')
{
--*scratch;
BMD(scratch+2,scratch+1,*scratch);
}
pData->personality.address = NewString(scratch);
pData->personality.realname = NewString(GetPref(scratch,PREF_REALNAME));
}
else
result = EMSR_NO_ENTRY;
CurPers = oldCur;
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return result;
}
/**********************************************************************
* ETLRegenerate - regenerate plugin filters or nicknames
**********************************************************************/
static pascal void ETLRegenerate(emsRegenerateDataP pData)
{
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
switch (pData->which)
{
case emsRegenerateFilters:
DisposeFilters(&PreFilters);
DisposeFilters(&PostFilters);
GeneratePluginFilters();
break;
case emsRegenerateNicknames:
ZapPluginAliases();
ReadPluginNickFiles(true);
break;
}
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
}
/**********************************************************************
* ETLGetDirectory - return indicated folder spec
**********************************************************************/
static pascal short ETLGetDirectory(emsGetDirectoryDataP pData)
{
short result = EMSR_OK;
OSErr err = noErr;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
switch (pData->which)
{
case EMS_EudoraDir: err = FSMakeFSSpec(Root.vRef,Root.dirId,"",&pData->directory); break;
case EMS_AttachmentsDir: err = GetAttFolderSpec(&pData->directory); break;
case EMS_PluginFiltersDir: err = ETLGetPluginFolderSpec(&pData->directory,PLUGIN_FILTERS); break;
case EMS_PluginNicknamesDir: err = ETLGetPluginFolderSpec(&pData->directory,PLUGIN_NICKNAMES); break;
case EMS_ConfigDir: err = ETLGetPluginFolderSpec(&pData->directory,0); break;
case EMS_MailDir: err = FSMakeFSSpec(MailRoot.vRef,MailRoot.dirId,"",&pData->directory); break;
case EMS_NicknamesDir: err = SubFolderSpec(NICK_FOLDER,&pData->directory); break;
case EMS_SignaturesDir: err = SubFolderSpec(SIG_FOLDER,&pData->directory); break;
case EMS_SpoolDir: err = SubFolderSpec(SPOOL_FOLDER,&pData->directory); break;
case EMS_StationeryDir: err = SubFolderSpec(STATION_FOLDER,&pData->directory); break;
default: result = EMSR_INVALID; break;
}
if (err)
result = EMSR_UNKNOWN_FAIL;
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return result;
}
/**********************************************************************
* ETLUpdateWindows - handle Eudora window updates
**********************************************************************/
static pascal void ETLUpdateWindows(void)
{
UpdateAllWindows();
}
/**********************************************************************
* ETLCanTranslate - can any of the translators take a whack?
**********************************************************************/
OSErr ETLCanTranslate(TLMHandle translators,short context,emsMIMEHandle tlMIME,tlStringHandle *errorStr,long *errCode,emsHeaderDataP addrList,HeaderDHandle hdh)
{
short t;
short nT;
OSErr err;
FSSpec spec;
OSErr result = TLR_CANT_TRANS;
short group = REAL_BIG;
Boolean fGeneratedHeaders = false;
emsHeaderData list;
Zero(spec); // just to keep the compiler quiet
if (!TLSelList) return(TLR_CANT_TRANS);
ETLSortTranslators(translators);
nT = HandleCount(translators)-1;
if (hdh && !addrList)
{
// Generate header info from header desc
ETLBuildAddrList(nil,nil,hdh,&list,context);
addrList = &list;
fGeneratedHeaders = true;
}
for (t=0;t<nT;t++)
{
// call can_translate
err = CanTranslateFile(&(*TLFL)[(*translators)[t].module],context,(*translators)[t].id,tlMIME,
errorStr,errCode, nil, addrList, nil);
if (!err) err = TLR_NOW;
ZapHandle(errorStr);
// record error
(*translators)[t].result = err;
// if they're willing, I'm willing!
if (err==TLR_NOT_NOW || err==TLR_NOW)
{
result = err;
break;
}
}
if (fGeneratedHeaders)
ETLDisposeAddrList(addrList);
return(result);
}
/**********************************************************************
* ETLTranslate - actually call the translators
**********************************************************************/
OSErr ETLTranslate(TLMHandle translators,short context,emsMIMEHandle tlMIME,
FSSpecPtr source,emsMIMEHandle *tlMIMEOut,tlStringHandle *textOut,FSSpecPtr into,
tlStringHandle *errorStr,long *errCode,emsHeaderDataP addrList)
{
short n = HandleCount(translators)-1;
short nGood=0;
OSErr err;
emsMIMEHandle localTLMIME=nil;
long localErr;
#ifdef DEBUG
#ifdef DEBUGFILES
static short dbCount;
Str255 dbStr;
FInfo info;
FSSpec temp;
if (RunType==Debugging)
{
FSMakeFSSpec(Root.vRef,Root.dirId,ComposeString(dbStr,"\pETInput %d",++dbCount),&temp);
FSpDupFile(&temp,source,True,False);
FSpGetFInfo(&temp,&info);
info.fdType = 'TEXT';
info.fdCreator = 'MPS ';
FSpSetFInfo(&temp,&info);
}
#endif
#endif
if (!errCode) errCode = &localErr;
/*
* set up the translator vector
*/
while(n--)
{
if ((*translators)[n].result == TLR_NOW) break;
}
if ((*translators)[n].result != TLR_NOW) return(TLR_CANT_TRANS);
/*
* call the translator
*/
err = MyTranslateFile (&(*TLFL)[(*translators)[n].module], context, (*translators)[n].id, tlMIME,
source, &localTLMIME, into, nil, textOut, errorStr, errCode ,nil,
addrList, nil, (*translators)[n].nameHandle);
if (err==TLR_ABORTED) err = userCanceledErr;
if (err && err!=userCanceledErr && errorStr && *errorStr) ETLError((*TLFL)[(*translators)[n].module].moduleDescription,ETL_CANT_TRANSLATE,*errorStr,err,*errCode);
//ZapHandle(errorStr);
if (err==EMSR_DATA_UNCHANGED || err==TLR_NOT_NOW)
{
RecordTLID(source,ETLID(translators,n));
(*translators)[n].result = TLR_NOT_NOW;
}
/*
* record output
*/
if (!err && localTLMIME)
{
RecordTLMIME(into,localTLMIME);
if (tlMIMEOut)
{
*tlMIMEOut = localTLMIME;
localTLMIME = nil;
}
}
if (localTLMIME) ZapTLMIME(localTLMIME);
return(err);
}
/**********************************************************************v
* NewTLMIME - Allocate a tlMIME structure
**********************************************************************/
OSErr NewTLMIME(emsMIMEHandle *tlMIME)
{
if (*tlMIME = NewZH(struct emsMIMEtypeS))
(**tlMIME)->size = sizeof(struct emsMIMEtypeS);
return(MemError());
}
/**********************************************************************v
* NewMIME - Allocate a MIME structure and add some defaults
**********************************************************************/
static OSErr NewMIME(emsMIMEHandle *tlMIME,short mimeType,short subType)
{
OSErr err = NewTLMIME(tlMIME);
if (!err)
{
emsMIMEtypeP pMIME;
pMIME = LDRef(*tlMIME);
// Set up some defaults
if (mimeType)
GetRString(pMIME->mimeType,mimeType);
if (subType)
GetRString(pMIME->subType,subType);
GetRString(pMIME->mimeVersion,MIME_VERSION); // Default MIME version is 1.0
UL(*tlMIME);
}
return err;
}
/**********************************************************************
* DisposeTLMIME - dispose of an emsMIME structure
**********************************************************************/
void DisposeTLMIME(emsMIMEHandle tlMIME)
{
if (tlMIME)
{
if (*tlMIME)
{
DisposeTLMIMEParam((*tlMIME)->params);
DisposeTLMIMEParam((*tlMIME)->contentParams);
}
ZapHandle(tlMIME);
}
}
/**********************************************************************
* DisposeTLMIMEParam - dispose of an emsMIME parameter list
**********************************************************************/
void DisposeTLMIMEParam(emsMIMEParamHandle param)
{
if (param)
{
if (*param)
{
if ((*param)->next) DisposeTLMIMEParam((*param)->next);
ZapHandle((*param)->value);
}
ZapHandle(param);
}
}
/**********************************************************************
* DisposeTLMIME - dispose of an old tlMIME structure
**********************************************************************/
static void DisposeOldTLMIME(tlMIMEtypeP tlMIME)
{
if (tlMIME)
{
if (*tlMIME) DisposeOldTLMIMEParam((*tlMIME)->params);
ZapHandle(tlMIME);
}
}
/**********************************************************************
* DisposeTLMIMEParam - dispose of an old parameter list
**********************************************************************/
static void DisposeOldTLMIMEParam(tlMIMEParamP param)
{
if (param)
{
if (*param)
{
if ((*param)->next) DisposeOldTLMIMEParam((*param)->next);
// Don't dispose of (*param)->value since we didn't make a copy of it
}
ZapHandle(param);
}
}
/************************************************************************
* RecordTLID - record the id of this translator
************************************************************************/
OSErr RecordTLID(FSSpecPtr spec,uLong id)
{
short oldResF = CurResFile();
Handle idHandle = NuHandle(sizeof(long));
short refN;
OSErr err;
if (!idHandle) return(MemError());
**(long**)idHandle = id;
refN = FSpOpenResFile(spec,fsRdWrPerm);
if (refN==-1) err = ResError();
else
{
AddResource(idHandle,'etlI',1001,"");
if (err=ResError()) ZapHandle(idHandle);
else
{
idHandle = nil;
err = MyUpdateResFile(refN);
CloseResFile(refN);
}
}
ZapHandle(idHandle);
UseResFile (oldResF);
return(err);
}
/**********************************************************************
*
**********************************************************************/
OSErr AddTLMIME(emsMIMEHandle tlMIME,short what,PStr name, PStr value)
{
UHandle h2=nil;
emsMIMEParamHandle h3=nil;
OSErr err = noErr;
switch(what)
{
/*
* put in the type
*/
case TLMIME_TYPE:
PSCopy((*tlMIME)->mimeType,name);
break;
/*
* put in the subtype
*/
case TLMIME_SUBTYPE:
PSCopy((*tlMIME)->subType,name);
break;
/*
* add a parameter
*/
case TLMIME_CONTENTDISP_PARAM:
case TLMIME_PARAM:
// already in the list?
for (h3=(what==TLMIME_PARAM ? (*tlMIME)->params : (*tlMIME)->contentParams);h3;h3=(*h3)->next)
{
if (StringSame(LDRef(h3)->name,name))
{
// append
UL(h3);
PtrPlusHand(value+1,(*h3)->value,*value);
if (MemError()) return(MemError());
(*(*h3)->value)[0] += *value;
return(noErr);
}
UL(h3);
}
// not in the list. Make a new one.
h3 = NewZH(struct emsMIMEparamS);
h2 = NuHTempBetter(*value);
if (h2 && h3)
{
PSCopy((*h3)->name,name);
BMD(value+1,*h2,*value);
(*h3)->value = h2;
if (what==TLMIME_PARAM)
LL_Queue((*tlMIME)->params,h3,(emsMIMEParamHandle));
else
LL_Queue((*tlMIME)->contentParams,h3,(emsMIMEParamHandle));
h2 = nil;
h3 = nil;
}
else
err = MemError();
break;
/*
* put in the MIME version
*/
case TLMIME_VERSION:
PSCopy((*tlMIME)->mimeVersion,name);
break;
/*
* put in the content-disposition
*/
case TLMIME_CONTENTDISP:
PSCopy((*tlMIME)->contentDisp,name);
break;
}
ZapHandle(h2);
ZapHandle(h3);
return(err);
}
/**********************************************************************
* FlattenTLMIME - take an awful tlMIME thing and turn it into a single handle
**********************************************************************/
OSErr FlattenTLMIME(emsMIMEHandle tlMIME,FlatTLMIMEHandle *flat)
{
Accumulator a;
OSErr err;
emsMIMEParamHandle p;
emsMIMEtype localType;
emsMIMEparam localParam;
short len;
/*
* complete?
*/
if (!tlMIME || !(*tlMIME)->mimeType || !(*tlMIME)->subType) return(fnfErr);
localType = **tlMIME;
/*
* add basic stuff
*/
if (!(err=AccuInit(&a)))
if (!(err=AccuAddPtr(&a,localType.mimeType,*localType.mimeType+1)))
if (!(err=AccuAddPtr(&a,localType.subType,*localType.subType+1)))
{
/*
* add params
*/
for (p=(*tlMIME)->params;!err && p;p=(*p)->next)
{
localParam = **p;
if (!(err=AccuAddPtr(&a,localParam.name,*localParam.name+1)))
{
len = GetHandleSize((*p)->value);
if (!(err=AccuAddPtr(&a,(void*)&len,2)))
err = AccuAddHandle(&a,(*p)->value);
}
}
}
/*
* failure?
*/
if (err) AccuZap(a);
else
{
AccuTrim(&a);
*flat = a.data;
}
return(err);
}
/**********************************************************************
* UnflattenTLMIME - take a handle and turn it into an awful tlMIME thing
**********************************************************************/
OSErr UnflattenTLMIME(FlatTLMIMEHandle flat,emsMIMEHandle *tlMIME)
{
OSErr err = noErr;
Str63 name;
Str255 value;
long offset=0;
long len;
short paramLen;
if (err = NewTLMIME(tlMIME)) return(err);
len = GetHandleSize(flat);
/*
* type
*/
if (!err && offset<len)
{
PSCopy(name,(*flat)+offset);
offset += *name+1;
err = AddTLMIME(*tlMIME,TLMIME_TYPE,name,nil);
ASSERT(!err);
}
else err = fnfErr; //missing parts
/*
* subtype
*/
if (!err && offset<len)
{
PSCopy(name,(*flat)+offset);
offset += *name+1;
err = AddTLMIME(*tlMIME,TLMIME_SUBTYPE,name,nil);
ASSERT(!err);
}
else err = fnfErr;
/*
* params
*/
while (!err && offset<len)
{
PSCopy(name,(*flat)+offset);
offset += *name+1;
if (offset<len)
{
paramLen = (((uShort)(*flat)[offset])<<256)|(*flat)[offset+1];
MakePStr(value,*flat+offset+2,paramLen);
offset += paramLen+2;
err = AddTLMIME(*tlMIME,TLMIME_PARAM,name,value);
ASSERT(!err);
}
else err = fnfErr;
}
/*
* failure?
*/
if (err) ZapTLMIME(*tlMIME);
return(err);
}
/**********************************************************************
* ETLInterpretFile - interpret a MIME file, possibly using a translator
* source - source filespec
* resultRefN - result fileref; this is where the text display will go
* resultAcc - result accumulator; this is where text will go if resultRefN nil
**********************************************************************/
OSErr ETLInterpretFile(short context,FSSpecPtr source, short resultRefN, AccuPtr resultAcc, emsHeaderDataP addrList,Boolean *dontSave)
{
OSErr err;
emsMIMEHandle tlMIME=nil;
TLMHandle translators=nil;
FSSpec tempSpec;
UHandle textH=nil;
emsMIMEHandle newtlMIME = nil;
Handle errorStr=nil;
long returnCode;
Zero(tempSpec);
if (!(err=ETLGetTLMIME(source,&tlMIME)))
if (!(err=ETLListAllTranslators(&translators,context)))
{
ETLSortTranslators(translators);
err = ETLCanTranslate(translators,context,tlMIME,nil,nil,addrList,nil);
if (err==TLR_CANT_TRANS)
{
err = ETLCopyFile(source,resultRefN,True,nil);
}
else if (err==TLR_NOT_NOW && context==EMSF_ON_ARRIVAL)
{
RecordTL(source,translators);
}
else if (!err || err==TLR_NOW)
{
NewTempSpec(Root.vRef,Root.dirId,nil,&tempSpec);
FSpCreateResFile(&tempSpec,CREATOR,MIME_FTYPE,smSystemScript);
returnCode = 0;
err = ETLTranslate(translators,context,tlMIME,source,&newtlMIME,&textH,&tempSpec,&errorStr,&returnCode,addrList);
DisposeTLMIME(newtlMIME);
if (err == EMSR_DELETE_MESSAGE)
{
// the translator has asked that the message be deleted
if (!PrefIsSet(PREF_ETL_IGNORE_DELETES)) ETLDeleteRequest = true;
err = EMSR_OK; // continue processing
}
if (!err)
{
// See if should be marked clean
if (returnCode & EMSF_DONTSAVE)
{
*dontSave = true;
returnCode &= ~EMSF_DONTSAVE;
}
if (!textH || !(err=ETLOutputPtr(LDRef(textH)+1,**textH,resultRefN,resultAcc)))
{
Boolean fDoSig = false;
short sigListCount;
if (textH) ETLOutputPtr("\015",1,resultRefN,resultAcc);
ZapHandle(textH);
if (gpSignList && returnCode == TLC_SIGOK && gpSignList->count < kMaxSignList)
{
// Beginning of signature decoration
sigListCount = gpSignList->count++;
GetFPos(resultRefN, &gpSignList->begin[sigListCount]);
fDoSig = true;
}
err = ETLInterpretFile(context,&tempSpec,resultRefN,resultAcc,addrList,dontSave);
if (fDoSig)
{
// End of signature decoration
GetFPos(resultRefN, &gpSignList->end[sigListCount]);
}
// if new translator doesn't want it now, copy back to original
if (err==TLR_NOT_NOW && context==EMSF_ON_ARRIVAL)
FSpExchangeFiles(source,&tempSpec);
}
}
}
}
if (err==EMSR_ABORTED) err = userCanceledErr;
if (err && err!=userCanceledErr && err!=EMSR_DATA_UNCHANGED)
if (errorStr) AlertStr(BIG_OK_ALRT,Stop,LDRef(errorStr));
else if (context!=EMSF_ON_ARRIVAL) WarnUser(ETL_TRANS_FAILED,err);
if (err==userCanceledErr) ETLDeleteRequest = false; // leave the message alone if the user cancelled.
FSpDelete(&tempSpec);
ZapHandle(textH);
ZapHandle(errorStr);
ZapTLMIME(tlMIME);
ZapHandle(translators);
return(err);
}
/**********************************************************************
* ETLGetTLMIME - read the tlMIME thing back out of a file
**********************************************************************/
OSErr ETLGetTLMIME(FSSpecPtr spec,emsMIMEHandle *tlMIME)
{
Handle res;
short refN;
OSErr err = fnfErr;
short oldResF = CurResFile();
*tlMIME = nil;
if (-1!=(refN=FSpOpenResFile(spec,fsRdPerm)))
{
if (res=Get1Resource(MIME_FTYPE,1001))
err=UnflattenTLMIME(res,tlMIME);
CloseResFile(refN);
}
if (err==fnfErr) err = ETLReadTLMIME(spec,tlMIME);
UseResFile (oldResF);
return(err);
}
/**********************************************************************
* ETLReadTL - read the translator out of a file
**********************************************************************/
OSErr ETLReadTL(FSSpecPtr spec,long *id)
{
short refN;
OSErr err=fnfErr;
Handle res;
short oldResF = CurResFile();
refN = FSpOpenResFile(spec,fsRdPerm);
if (refN==-1) err = ResError();
else
{
if (res=GetResource('etlI',1001))
{
err = noErr;
*id = **(long**)res;
}
CloseResFile(refN);
}
UseResFile (oldResF);
return(err);
}
/**********************************************************************
* ETLReadTLMIME - read mime info
**********************************************************************/
OSErr ETLReadTLMIME(FSSpecPtr spec,emsMIMEHandle *tlMIME)
{
HeaderDHandle hdh = nil;
OSErr err = ETLCopyFile(spec,0,False,&hdh);
if (!err && hdh)
{
*tlMIME = (*hdh)->tlMIME;
(*hdh)->tlMIME = nil;
ZapHeaderDesc(hdh);
}
else if (!hdh)
{
err = NewMIME(tlMIME,MIME_TEXT,MIME_PLAIN);
}
return(err);
}
/**********************************************************************
* ETLCopyFile - copy a MIME file
**********************************************************************/
OSErr ETLCopyFile(FSSpecPtr spec,short refN,Boolean display,HeaderDHandle *theHeaders)
{
LineIOD lid;
LineIOP lip;
OSErr err;
UHandle buf = nil;
long size = GetRLong(BUFFER_SIZE);
/*
* set up stack, lineio, io buffer
*/
if (!TransContextStack && (err=StackInit(sizeof(LineIOP),&TransContextStack)))
return(WarnUser(ETL_TRANS_FAILED,err));
if (err=OpenLine(spec->vRefNum,spec->parID,spec->name,fsRdWrPerm,&lid))
return(FileSystemError(ETL_TRANS_FAILED,spec->name,err));
if (!(buf = NewIOBHandle(256,size))) err = MemError();
/*
* do the work
*/
lip = &lid;
if (buf && !(err=StackPush(&lip,TransContextStack)))
{
TransVector oldTrans = CurTrans;
CurTrans = TransTrans;
size = GetHandleSize(buf);
MoveHHi(buf);
err = ReadHeadAndBody(NULL,refN,LDRef(buf),size,display,theHeaders); //NULL is probably OK here. JDB 6/7/97
StackPop(nil,TransContextStack);
CurTrans = oldTrans;
}
/*
* cleanup
*/
CloseLine(&lid);
ZapHandle(buf);
if (err) WarnUser(ETL_TRANS_FAILED,err);
return(err);
}
/**********************************************************************
* ETLDisplayFile - display the contents of a file
**********************************************************************/
OSErr ETLDisplayFile(FSSpecPtr spec,PETEHandle pte)
{
FSSpec tempSpec;
OSErr err = noErr;
short refN;
MyWindowPtr win;
WindowPtr winWP;
long sel;
Str255 title;
long oldLen;
SignOffsetList signList;
Boolean dontSave = false;
UHandle textH;
TOCHandle tocH;
short sumNum;
AnyRich = AnyHTML = AnyFlow = AnyCharset = False;
if (err = NewTempSpec(Root.vRef,Root.dirId,nil,&tempSpec))
WarnUser(ETL_TRANS_FAILED,err);
else
{
FSpCreate(&tempSpec,CREATOR,'TEXT',smSystemScript);
if (err=FSpOpenDF(&tempSpec,fsRdWrPerm,&refN))
FileSystemError(ETL_TRANS_FAILED,tempSpec.name,err);
else
{
Handle hSignBounds = nil;
emsHeaderData addrList;
// Set up list to keep track of signature bars
gpSignList = &signList;
signList.count = 0;
// grab cache if we can
win = (*PeteExtra(pte))->win;
winWP = GetMyWindowWindowPtr(win);
textH = PeteText(pte);
sumNum = -1;
if (GetWindowKind(winWP) == MBOX_WIN)
{
tocH = (TOCHandle)GetMyWindowPrivateData(win);
if (pte==(*tocH)->previewPTE) sumNum = FirstMsgSelected(tocH);
}
else if (GetWindowKind(winWP) == MESS_WIN)
{
tocH = (*Win2MessH(win))->tocH;
sumNum = (*Win2MessH(win))->sumNum;
}
if (sumNum>=0)
{
CacheMessage(tocH,sumNum);
if ((*tocH)->sums[sumNum].cache)
HNoPurge((*tocH)->sums[sumNum].cache);
else
sumNum = -1;
}
// build the address list
ETLBuildAddrList(textH,nil,nil,&addrList,EMSF_Q4_TRANSMISSION);
if (sumNum!=-1) HPurge((*tocH)->sums[sumNum].cache);
err=ETLInterpretFile(TLF_ON_DISPLAY,spec,refN,nil,&addrList,&dontSave);
ETLDisposeAddrList(&addrList);
if (!err)
{
/*My - no need for flush */FSClose(refN); refN = 0;
if (pte)
{
PeteGetTextAndSelection(pte,nil,nil,&sel);
PETESelect(PETE,pte,sel,sel);
PeteSetURLRescan(pte,sel);
PetePlain(pte,kPETECurrentStyle,kPETECurrentStyle,peAllValid);
PETEInsertTextPtr(PETE,pte,-1,"\015\015",2,nil);
sel += 2; // Added 2 cr's
PETESelect(PETE,pte,sel,sel);
oldLen = PETEGetTextLen(PETE,pte);
err = InsertTextFile((*PeteExtra(pte))->win,&tempSpec,AnyRich||AnyHTML||AnyFlow||AnyCharset||AnyDelSP,AnyDelSP);
if (signList.count)
{
// Mark signatures
short sigIdx;
for (sigIdx=0;sigIdx<signList.count;sigIdx++)
{
long offsetBegin,offsetEnd,paraBegin,paraEnd,paraIdx;
PETEParaInfo pinfo;
offsetBegin = sel+signList.begin[sigIdx];
offsetEnd = sel+signList.end[sigIdx];
PeteEnsureBreak(pte,offsetBegin);
PeteEnsureBreak(pte,offsetEnd);
paraBegin = PeteParaAt(pte,offsetBegin);
paraEnd = PeteParaAt(pte,offsetEnd);
pinfo.tabHandle = nil;
PETEGetParaInfo(PETE,pte,kPETECurrentSelection,&pinfo); // Get the paragraph style here
pinfo.signedLevel++;
// Mark each paragraph
for (paraIdx = paraBegin;paraIdx <= paraEnd;paraIdx++)
PETESetParaInfo(PETE,pte,paraIdx,&pinfo,peSignedLevelValid);
}
// Restore original selection
PETESelect(PETE,pte,sel,sel);
}
}
else
{
GetRString(title,UNTITLED);
err = !(win=OpenText(&tempSpec,nil,nil,nil,True,title,False,False));
if (win) (*(TextDHandle)GetMyWindowPrivateData(win))->spec.vRefNum = 0;
}
WipeSpec(&tempSpec);
}
gpSignList = nil;
}
if (refN) /*My - no need for flush */FSClose(refN);
FSpDelete(&tempSpec);
}
if (dontSave && pte)
{
PeteCleanList(pte);
(*PeteExtra(pte))->win->isDirty = false;
}
return err;
}
/**********************************************************************
* ETLNameAndIcon - get translator name and icon
**********************************************************************/
void ETLNameAndIcon(short i,PStr name,Handle *suite)
{
*suite = (*TLFL)[i].moduleSuite;
PCopy(name,*(*TLFL)[i].moduleDescription);
}
/**********************************************************************
* TransRecvLine - receive a line for a translator
**********************************************************************/
OSErr TransRecvLine(TransStream stream, UPtr line,long *size)
{
#pragma unused (stream)
OSErr err;
LineIOP lip;
short result;
static Boolean wasNl=True;
err = StackTop(&lip,TransContextStack);
ASSERT(!err);
if (!err)
{
result = NLGetLine(line,*size,size,lip);
err = result<0;
if (!result)
{
*size = 2;
line[0]='.'; line[1]='\015'; line[2] = 0;
}
else if (wasNl && line[0]=='.')
{
BMD(line,line+1,*size);
++*size;
}
wasNl = line[*size]=='\015';
}
return(err);
}
/**********************************************************************
* ETLError - error with translator
**********************************************************************/
short ETLError(tlStringHandle description,short context,tlStringHandle errorStr,OSErr err,long subError)
{
Str255 string, error;
if (description) PSCopy(string,*description); else *string = 0;
if (errorStr) PSCopy(error,*errorStr); else *error = 0;
return(Aprintf(BIG_OK_ALRT,Caution,ETL_ERROR_FMT,string,context,error,err,subError));
}
/**********************************************************************
* ETLAddIcons - add translator icons to the composition window
**********************************************************************/
OSErr ETLAddIcons(MyWindowPtr win,short startNumber)
{
WindowPtr winWP = GetMyWindowWindowPtr (win);
ControlHandle theCtl;
short i;
Handle suite;
Rect r;
OSErr err = fnfErr;
long flags;
Zero(r);
if (TLQ4List)
{
for (i=HandleCount(TLQ4List);i--;)
{
flags = (*TLQ4List)[i].flags;
if (suite = (*TLQ4List)[i].suite)
{
if (theCtl = GetNewControlSmall(ICON_BAR_CNTL,winWP))
{
err = noErr; // found at least one
EmbedControl(theCtl,win->topMarginCntl);
SetBevelIcon(theCtl,0,0,0,suite);
SetControlReference(theCtl, 0xff000000 | startNumber+i);
(*Win2MessH(win))->nTransIcons++;
if (InTranslator((*Win2MessH(win))->hTranslators,ETLIconToID(i)))
SetControlValue(theCtl,1);
else if (SumOf(Win2MessH(win))->length==0 && flags & EMSF_DEFAULT_Q_ON)
{
// Default is on
// Turn on the translator
StringHandle properties = nil;
long selected;
selected = true;
QueuedProperties(i,&selected,&properties,true);
if (selected)
AddMessTranslator(Win2MessH(win),i,properties);
}
}
}
}
}
return(err);
}
/**********************************************************************
* ETLIconToID - turn an icon index into an id
**********************************************************************/
long ETLIconToID(short which)
{
if (TLQ4List && which<HandleCount(TLQ4List)) return(((*TLFL)[(*TLQ4List)[which].module].moduleID<<16L)|(*TLQ4List)[which].id);
else return(0);
}
/**********************************************************************
* ETLIconToDescriptions - grab the descriptions for a translator
**********************************************************************/
OSErr ETLIconToDescriptions(short which,PStr module,PStr translator)
{
if (TLQ4List && which<HandleCount(TLQ4List))
{
PCopy(module,*(*TLFL)[(*TLQ4List)[which].module].moduleDescription);
PCopy(translator,*(*TLQ4List)[which].nameHandle);
return(noErr);
}
else
{
*module = *translator = 0;
return(fnfErr);
}
}
/**********************************************************************
* ETLIDToIndex - turn an id into an index
**********************************************************************/
short ETLIDToIndex(long id)
{
short module = (id>>16)&0xffff;
short translator = id & 0xffff;
short index;
if (TLQ4List)
for (index = HandleCount(TLQ4List);index--;)
if ((*TLFL)[(*TLQ4List)[index].module].moduleID==module && (*TLQ4List)[index].id==translator)
return(index);
return(-1);
}
#define M_FTYPE MIME_FTYPE
/**********************************************************************
* ETLQueueMessage - if we have any ON_COMPLETION translators, translate how
**********************************************************************/
short ETLQueueMessage(MessHandle messH)
{
OSErr err = noErr;
TransInfoHandle translators = (*messH)->hTranslators;
Boolean doCompletion = false;
short i;
Str32 s;
// Got any ON_COMPLETION translators?
if (translators)
{
long flags = SumOf(messH)->flags;
for (i=HandleCount(translators);i--;)
{
short index;
index = ETLIDToIndex((*translators)[i].id);
if (index>=0 && (*TLQ4List)[index].flags & EMSF_Q4_COMPLETION)
{
doCompletion = true;
break;
}
}
}
if (doCompletion)
{
FSSpec raw, cooked;
OSErr transErr = 0;
// Do all EMSF_Q4_COMPLETION and EMSF_Q4_TRANSMISSION translators
if (!(err=NewTempSpec(Root.vRef,Root.dirId,nil,&raw)))
if (!(err=FSpCreate(&raw,CREATOR,M_FTYPE,smSystemScript)))
{
Uhandle text=nil;
HeadSpec hs;
// Create destination file in spool folder with same name as subject
if (!(err=MakeAttSubFolder(messH,SumOf(messH)->uidHash,&cooked)))
if (CompHeadFind(messH,SUBJ_HEAD,&hs) &&
!(CompHeadGetText(TheBody,&hs,&text)))
{
short saveLen;
short suffix = 2;
// Get Subject
MakePStr(cooked.name,*text,GetHandleSize(text));
ZapHandle(text);
// Make sure we have a unique file name
saveLen = *cooked.name;
while (!FSpExists(&cooked))
{
// No error means that the file/folder exists. Change the file name by adding a numeric suffix
NumToString(suffix++,s);
if (saveLen+*s > 30)
saveLen = 30-*s; // Name was too long
*cooked.name = saveLen; // Remove any suffix
PCatC(cooked.name,' ');
PCat(cooked.name,s);
}
if (!(err=FSpCreate(&cooked,CREATOR,M_FTYPE,smSystemScript)))
{
emsMIMEHandle tlMIME = nil;
short refN;
// Get raw message
if (!(err=FSpOpenDF(&raw,fsRdWrPerm,&refN)))
{
err = WriteMailFile(messH,refN,True,&tlMIME);
FSClose(refN);
}
// Do translation
if (!err) err = ETLTransOut(messH,tlMIME,&raw,&cooked);
transErr = err;
if (!err)
{
CompAttachSpec((*messH)->win,&cooked);
CompHeadFind(messH,0,&hs);
PeteDelete((*messH)->bodyPTE,hs.value,hs.stop);
ZapHandle(translators);
(*messH)->hTranslators = nil;
}
ZapTLMIME(tlMIME);
}
}
PrefIsSet(PREF_WIPE) ? WipeSpec(&raw):FSpDelete(&raw);
}
if (err && err!=userCanceledErr && !transErr) WarnUser(GENERAL,err);
}
return(err);
}
/**********************************************************************
* ETLSendMessage - send a message with the translators
**********************************************************************/
short ETLSendMessage(TransStream stream,MessHandle messH,Boolean chatter,Boolean sendDataCmd)
{
FSSpec raw, cooked;
OSErr err;
short refN;
long flags = SumOf(messH)->flags;
emsMIMEHandle tlMIME = nil;
OSErr transErr = 0;
if (!(err=NewTempSpec(Root.vRef,Root.dirId,nil,&raw)))
if (!(err=FSpCreate(&raw,CREATOR,M_FTYPE,smSystemScript)))
if (!(err=NewTempSpec(Root.vRef,Root.dirId,nil,&cooked)))
if (!(err=FSpCreate(&cooked,CREATOR,M_FTYPE,smSystemScript)))
{
{
if (!(err=FSpOpenDF(&raw,fsRdWrPerm,&refN)))
{
err = WriteMailFile(messH,refN,True,&tlMIME);
/*My - no need for flush */FSClose(refN);
}
if (!err) err = ETLTransOut(messH,tlMIME,&raw,&cooked);
transErr = err;
if (!err)
{
if (!(err=TransmitMessage(stream,messH,chatter,False,True,nil,sendDataCmd)))
if (!(err = SendRawMIME(stream,&cooked))) err = FinishSMTP(stream,messH);
}
}
PrefIsSet(PREF_WIPE) ? WipeSpec(&raw):FSpDelete(&raw);
if (*cooked.name) FSpDelete(&cooked);
}
if (err && err!=userCanceledErr && !transErr) WarnUser(GENERAL,err);
ZapTLMIME(tlMIME);
return(err);
}
/**********************************************************************
* ETLCanTransOut - can we translate this thing?
**********************************************************************/
OSErr ETLCanTransOut(MessHandle messH)
{
emsHeaderData list;
OSErr err = ETLBuildAddrList(PeteText(TheBody),(*messH)->extras.data,nil,&list,EMSF_Q4_TRANSMISSION);
TLMHandle transList=nil;
emsMIMEHandle tlmHandle=nil;
short i,n;
Handle errorStr=nil;
long errCode;
if (!err)
{
if (!(err=ETLListRequestedTranslators(&transList,(*messH)->hTranslators)))
{
short mimeType,subType;
if (MessFlagIsSet(messH,FLAG_HAS_ATT))
{
mimeType = MIME_MULTIPART;
subType = MIME_MIXED;
}
else
{
mimeType = MIME_TEXT;
subType = MIME_PLAIN;
}
if (!(err=NewMIME(&tlmHandle,mimeType,subType)))
{
n = HandleCount(transList);
for (i=0;i<n-1;i++)
{
err = CanTranslateFile(&(*TLFL)[(*transList)[i].module],EMSF_Q4_TRANSMISSION,(*transList)[i].id,
tlmHandle,&errorStr,&errCode,nil,&list,messH);
if (err==TLR_ABORTED) err = userCanceledErr;
if (err && err!=userCanceledErr && err!=TLR_NOW) ETLError((*TLFL)[(*transList)[i].module].moduleDescription,ETL_CANT_TRANSLATE,errorStr,err,errCode);
ZapHandle(errorStr);
if (!err) err = TLR_NOW;
if (err!=TLR_NOW) break;
}
}
}
}
ZapHandle(transList);
ETLDisposeAddrList(&list);
ZapTLMIME(tlmHandle);
return(err);
}
/**********************************************************************
* ETLTransOut - actually translate something
**********************************************************************/
OSErr ETLTransOut(MessHandle messH,emsMIMEHandle tlMIME,FSSpecPtr from,FSSpecPtr to)
{
emsHeaderData addrList;
OSErr err;
TLMHandle transList=nil;
err = ETLBuildAddrList(PeteText(TheBody),(*messH)->extras.data,nil,&addrList,EMSF_Q4_TRANSMISSION);
if (!err)
{
if (!(err=ETLListRequestedTranslators(&transList,(*messH)->hTranslators)))
err = ETLTransOutLow(transList,&addrList,tlMIME,from,to,messH);
}
ZapHandle(transList);
ETLDisposeAddrList(&addrList);
return(err);
}
/**********************************************************************
* ETLTransOutLow - perform first translation in the list, and recurse
**********************************************************************/
static OSErr ETLTransOutLow(TLMHandle transList,emsHeaderDataP addrList,
emsMIMEHandle tlMIME,FSSpecPtr from,FSSpecPtr into,MessHandle messH)
{
OSErr err;
short n,i;
FSSpec temp;
emsMIMEHandle tlMIMEOut=nil;
tlStringHandle errorStr=nil;
long localErr;
StringHandle properties;
#ifdef DEBUG
#ifdef DEBUGFILES
static short dbCount;
Str255 dbStr;
FInfo info;
if (RunType==Debugging)
{
FSMakeFSSpec(Root.vRef,ComposeString(dbStr,"\pEOInput %d",++dbCount),&temp);
FSpDupFile(&temp,from,True,False);
FSpGetFInfo(&temp,&info);
info.fdType = 'TEXT';
info.fdCreator = 'MPS ';
FSpSetFInfo(&temp,&info);
}
#endif
#endif
Zero(temp);
// Look for queued properties
properties = GetQueuedProperties(messH,((*TLFL)[(*transList)[0].module].moduleID<<16L)|(*transList)[0].id);
err = CanTranslateFile(&(*TLFL)[(*transList)[0].module],EMSF_Q4_TRANSMISSION,(*transList)[0].id,
tlMIME,&errorStr,&localErr,properties,addrList,messH);
if (err==TLR_ABORTED) err = userCanceledErr;
if (!err) err = TLR_NOW;
if (err!=TLR_NOW && err!=userCanceledErr)
{
ETLError((*TLFL)[(*transList)[0].module].moduleDescription,ETL_CANT_TRANSLATE,errorStr,err,localErr);
}
else
{
ZapHandle(errorStr);
err = MyTranslateFile (&(*TLFL)[(*transList)[0].module], EMSF_Q4_TRANSMISSION, (*transList)[0].id, tlMIME,
from, &tlMIMEOut,into, nil, nil, &errorStr, &localErr, properties,
addrList, messH, (*transList)[0].nameHandle);
if (err==TLR_ABORTED) err = userCanceledErr;
if (err && err!=EMSR_DATA_UNCHANGED)
{
if (err!=userCanceledErr) ETLError((*TLFL)[(*transList)[0].module].moduleDescription,ETL_CANT_TRANSLATE,errorStr,err,localErr);
WipeSpec(into);
}
else
{
ZapHandle(errorStr);
if (err==EMSR_DATA_UNCHANGED)
{
// Data unchanged, so put from file into into file and we're done
if (err=FSpExchangeFiles(from,into))
FileSystemError(ETL_CANT_TRANSLATE,from->name,err);
else
err = 0;
}
else
RecordTLMIME(into,tlMIMEOut);
if (!err)
{
n = HandleCount(transList);
if (n>2)
{
for (i=0;i<n-1;i++) (*transList)[i] = (*transList)[i+1];
SetHandleSize((Handle)transList,(n-1)*sizeof(**transList));
NewTempSpec(into->vRefNum,into->parID,nil,&temp);
FSpCreate(&temp,CREATOR,MIME_FTYPE,smSystemScript);
if (err=ResError()) FileSystemError(ETL_CANT_TRANSLATE,temp.name,err);
else if (err=FSpExchangeFiles(&temp,into))
{
WipeSpec(&temp);
FileSystemError(ETL_CANT_TRANSLATE,temp.name,err);
}
else
{
err = ETLTransOutLow(transList,addrList,tlMIMEOut,&temp,into,messH);
WipeSpec(&temp);
}
}
}
}
}
ZapHandle(errorStr);
ZapTLMIME(tlMIMEOut);
return(err);
}
/**********************************************************************
* MakeAddress - return a emsAddressH for the indicated address
**********************************************************************/
static emsAddressH MakeAddress(StringPtr sAddress,StringPtr sName)
{
emsAddressH hAddress = nil;
if ((*sAddress || *sName) && (hAddress=NuHandleClear(sizeof(emsAddress))))
{
emsAddressP pAddress;
pAddress = LDRef(hAddress);
pAddress->size = sizeof(emsAddress);
if (*sAddress)
pAddress->address = NewString(sAddress);
if (*sName)
pAddress->realname = NewString(sName);
UL(hAddress);
}
return hAddress;
}
/**********************************************************************
* GetAddressesFromHandle - get addresses from a handle
**********************************************************************/
static emsAddressH GetAddressesFromHandle(Uhandle text,Boolean expandNicks)
{
UHandle addr;
UHandle rawAddresses;
short err=0;
Str255 s;
Str255 raw;
emsAddressH hAddress = nil;
emsAddressH hLastAddress = nil;
emsAddressH hFirstAddress = nil;
err=SuckAddresses(&rawAddresses,text,True,false,False,nil);
ZapHandle(text);
if (rawAddresses && **rawAddresses)
{
long offset;
if (expandNicks)
{
ExpandAliases(&addr,rawAddresses,0,True);
ZapHandle(rawAddresses);
}
else
addr = rawAddresses;
for (offset=0;!err && (*addr)[offset];offset+=(*addr)[offset]+2)
{
MakePStr(raw,(*addr)+offset+1,(*addr)[offset]);
ShortAddr(s,raw);
//Folder Carbon Copy no FCC's in Light. Flag them as wrong
if (HasFeature (featureFcc))
if (IsFCCAddr(s)) continue; // skip fcc's
BeautifyFrom(raw);
if (StringSame(raw,s))
*raw = 0; // No real name
if (hAddress = MakeAddress(s,raw))
{
if (hLastAddress)
(*hLastAddress)->next = hAddress;
hLastAddress = hAddress;
if (!hFirstAddress)
hFirstAddress = hAddress;
}
}
ZapHandle(addr);
}
return hFirstAddress;
}
/**********************************************************************
* GetAddressesFromHeader - get addresses from a header
**********************************************************************/
static emsAddressH GetAddressesFromHeader(UHandle textIn,short header,Boolean expandNicks)
{
short err=0;
Uhandle text=nil;
emsAddressH hFirstAddress = nil;
HeadSpec hs;
Str63 hName;
if (HandleHeadFindStr(textIn,header?GetRString(hName,HeaderStrn+header):"",&hs) &&
!(err=HandleHeadGetText(textIn,&hs,&text)))
{
hFirstAddress = GetAddressesFromHandle(text,expandNicks);
}
return hFirstAddress;
}
/**********************************************************************
* - get addresses from a header
**********************************************************************/
static emsAddressH FindAddress(Accumulator acc, short index,Boolean expandNicks)
{
short err=0;
Uhandle text=nil;
emsAddressH hAddress = nil;
emsAddressH hLastAddress = nil;
emsAddressH hFirstAddress = nil;
Str32 name;
UPtr pHeader;
long length;
GetRString(name,HeaderStrn+index);
length = acc.offset;
if (pHeader = FindHeaderString(*acc.data,name,&length,false))
{
PtrToHand(pHeader, &text, length);
hFirstAddress = GetAddressesFromHandle(text,expandNicks);
}
return hFirstAddress;
}
/**********************************************************************
* ETLBuildAddrList - build an address list
**********************************************************************/
OSErr ETLBuildAddrList(UHandle textIn,UHandle moreHeaders,HeaderDHandle hdh,emsHeaderDataP addrList,short context)
{
Str255 sName;
HeadSpec hs;
Uhandle text=nil;
Accumulator acc;
WriteZero(addrList,sizeof(emsHeaderData));
addrList->size = sizeof(emsHeaderData);
if (textIn || hdh)
{
if (gTranslatorFlags & (EMSF_BASIC_HEADERS+EMSF_ALL_HEADERS))
{
// Do BASIC headers
Boolean expandNicks = ContextRequiresExpansion(context);
if (textIn)
{
// Get from message header
// Get From, To, CC, BCC headers
addrList->from = GetAddressesFromHeader(textIn,FROM_HEAD,expandNicks);
addrList->to = GetAddressesFromHeader(textIn,TO_HEAD,expandNicks);
addrList->cc = GetAddressesFromHeader(textIn,CC_HEAD,expandNicks);
addrList->bcc = GetAddressesFromHeader(textIn,BCC_HEAD,expandNicks);
// Get Subject
if (HandleHeadFindStr(textIn,GetRString(sName,HeaderStrn+SUBJ_HEAD),&hs) &&
!(HandleHeadGetText(textIn,&hs,&text)))
{
MakePStr(sName,*text,GetHandleSize(text));
addrList->subject = NewString(sName);
ZapHandle(text);
}
}
else
{
long length;
UPtr pHeader;
acc = (*hdh)->fullHeaders;
HLock(acc.data);
// Get From, To, CC, BCC headers
addrList->from = FindAddress(acc,FROM_HEAD,expandNicks);
addrList->to = FindAddress(acc,TO_HEAD,expandNicks);
addrList->cc = FindAddress(acc,CC_HEAD,expandNicks);
addrList->bcc = FindAddress(acc,BCC_HEAD,expandNicks);
// Get Subject
GetRString(sName,HeaderStrn+SUBJ_HEAD);
length = acc.offset;
if (pHeader = FindHeaderString(*acc.data,sName,&length,false))
{
MakePStr(sName,pHeader,length);
addrList->subject = NewString(sName);
}
HUnlock(acc.data);
}
}
if ((gTranslatorFlags & EMSF_ALL_HEADERS) && (context==EMSF_ON_ARRIVAL || context==EMSF_ON_DISPLAY || context==EMSF_Q4_TRANSMISSION || context==EMSF_ON_REQUEST))
{
// Get raw 822 headers
if (textIn)
{
if (HandleHeadFindStr(textIn,"",&hs))
{
hs.stop = hs.start-1;
hs.start = 0;
hs.value = 0;
if (!(HandleHeadGetText(textIn,&hs,&text)))
{
addrList->rawHeaders = text;
if (moreHeaders) HandPlusHand(moreHeaders,text);
}
}
}
else
{
acc = (*hdh)->fullHeaders;
HLock(acc.data);
PtrToHand(*acc.data, &addrList->rawHeaders, acc.offset);
HUnlock(acc.data);
}
}
}
return(noErr);
}
/**********************************************************************
* ETLBuildOldAddrList - build a translation address list for version 1
**********************************************************************/
OSErr ETLBuildOldAddrList(MessHandle messH,tlAddrListHandle *addrList,Boolean expandNicks)
{
Accumulator a;
OSErr err = AccuInit(&a);
BinAddrHandle addr = NuHandle(0);
Str255 s;
Str255 raw;
long offset;
long theNil = 0;
if (!err && !(err=MemError()))
{
MessReturnAddr(messH,s);
if (!(err=AccuAddHandleToPtr(&a,s,*s+1)))
{
GetRealname(s);
if (*s)
err=AccuAddHandleToPtr(&a,s,*s+1);
else
err=AccuAddPtr(&a,(void*)&theNil,sizeof(addr));
if (!err)
if (!(err=AccuAddPtr(&a,(void*)&theNil,sizeof(addr))))
{
if (!(err = GatherCompAddresses((*messH)->win,addr)))
{
if (expandNicks)
{
BinAddrHandle exp;
if (!(err=ExpandAliases(&exp,addr,0,true)))
{
ZapHandle(addr);
addr = exp;
}
}
for (offset=0;!err && (*addr)[offset];offset+=(*addr)[offset]+2)
{
MakePStr(raw,(*addr)+offset+1,(*addr)[offset]);
ShortAddr(s,raw);
//Folder Carbon Copy no FCC's in Light. Flag them as wrong
if (HasFeature (featureFcc))
if (IsFCCAddr(s)) continue; // skip fcc's
if (!(err=AccuAddHandleToPtr(&a,s,*s+1)))
{
BeautifyFrom(raw);
if (!(err=AccuAddHandleToPtr(&a,raw,*raw+1)))
err=AccuAddPtr(&a,(void*)&theNil,sizeof(addr));
}
}
}
}
}
}
if (!err) err = AccuAddPtr(&a,(void*)&theNil,sizeof(addr));
if (!err)
{
AccuTrim(&a);
*addrList = (void*)a.data;
a.data = nil;
}
ZapHandle(addr);
AccuZap(a);
return(err);
}
/**********************************************************************
* ZapAddress - dispose of an address list
**********************************************************************/
static void ZapAddress(emsAddressH addr)
{
emsAddressH next;
while (addr)
{
StringHandle address, name;
if (address = (*addr)->address) DisposeHandle(address);
if (name = (*addr)->realname) DisposeHandle(name);
next = (*addr)->next;
DisposeHandle((Handle)addr);
addr = next;
}
}
/**********************************************************************
* DisposeAddrList - destroy a translation address list thing
**********************************************************************/
void ETLDisposeAddrList(emsHeaderDataP addrList)
{
if (addrList)
{
ZapAddress(addrList->to);
ZapAddress(addrList->from);
ZapAddress(addrList->cc);
ZapAddress(addrList->bcc);
ZapHandle(addrList->subject);
ZapHandle(addrList->rawHeaders);
}
}
/**********************************************************************
* DisposeOldAddrList - destroy a version 1 translation address list thing
**********************************************************************/
static void DisposeOldAddrList(tlAddrListHandle addrList)
{
short i;
if (addrList)
{
for (i=HandleCount(addrList);i--;) ZapHandle((*addrList)[i]);
ZapHandle(addrList);
}
}
/**********************************************************************
* ETLTransSelection - translate the selection in a window
**********************************************************************/
OSErr ETLTransSelection(PETEHandle pte,HSPtr hs,short item)
{
short n = HandleCount(TLSelList);
TLMaster tlm;
UHandle text=nil;
OSErr err = noErr;
long len;
while (n-- && (*TLSelList)[n].menuItem!=item);
if (n<0) return(WarnUser(ETL_CANT_FIND_TRANS,item));
tlm = (*TLSelList)[n];
if (tlm.flags & TLF_REQUIRES_MIME) return(WarnUser(ETL_IM_STUPID,0));
if (tlm.flags & EMSF_ALL_TEXT)
{
// Use all text
hs->start = hs->value = 0;
hs->stop = PETEGetTextLen(PETE,pte);
}
if ((CurrentModifiers()&optionKey) && PeteParaAt(pte,hs->start)!=PeteParaAt(pte,hs->stop) && UseFlowIn)
{
LightQuote(pte,hs->start,hs->stop,&hs->start,&hs->stop);
hs->value = hs->start;
PeteSelect(nil,pte,hs->start,hs->stop);
PeteWrap(nil,pte,true);
PeteGetTextAndSelection(pte,nil,&hs->start,&hs->stop);
hs->value = hs->start;
}
if (!(err=CompHeadGetText(pte,hs,&text)))
{
#ifdef NEVER
if () err = ETLTransHandleBuf(&text,&tlm);
else
#endif
err = ETLTransHandleFile(&text,&tlm,pte);
len = GetHandleSize(text);
if (!err)
{
PetePrepareUndo(pte,peUndoPaste,hs->value,hs->stop,nil,nil);
if (!(err = PeteDelete(pte,hs->value,hs->stop)))
if (!(err = PETEInsertText(PETE,pte,hs->value,text,nil)))
{
text = nil;
PeteSelect((*PeteExtra(pte))->win,pte,hs->value,hs->value+len);
}
PeteFinishUndo(pte,peUndoPaste,hs->value,hs->value+len);
PeteChanged(pte,hs->value,hs->value+len);
}
}
ZapHandle(text);
return(err);
}
#ifdef NEVER
/**********************************************************************
* ETLTransHandleBuf - translate a handle, using the buffer calls
**********************************************************************/
OSErr ETLTransHandleBuf(UHandle *text,TLMPtr tlm)
{
return(WarnUser(ETL_IM_STUPID,1));
}
#endif
/**********************************************************************
* ETLTransHandleFile - translate a handle, using files as intermediaries
**********************************************************************/
static OSErr ETLTransHandleFile(UHandle *text,TLMPtr tlm,PETEHandle pte)
{
FSSpec raw, translated;
OSErr err;
UHandle errorStr = nil;
emsMIMEHandle tlMIME = nil;
Handle headers=nil;
long localErr;
long len;
long bo;
emsMIMEHandle localTLMIME=nil;
emsHeaderData addrList;
#ifdef DEBUG
#ifdef DEBUGFILES
static short dbCount;
Str255 dbStr;
FInfo info;
FSSpec temp;
#endif
#endif
Zero(raw);
Zero(translated);
PlainTextMIMEStuff(&tlMIME,(tlm->flags&TLF_REQUIRES_MIME) ? &headers : nil);
NewTempSpec(Root.vRef,Root.dirId,nil,&raw);
NewTempSpec(Root.vRef,Root.dirId,nil,&translated);
if ((tlm->flags&TLF_REQUIRES_MIME) && (err=AddLf(*text)) ||
(err=FSpCreate(&raw,CREATOR,'TEXT',smSystemScript)) ||
(err=FSpCreate(&translated,CREATOR,'TEXT',smSystemScript)) ||
(headers && (err=Blat(&raw,headers,False))) ||
(err=Blat(&raw,*text,True)))
FileSystemError(ETL_CANT_TRANSLATE,raw.name,err);
else
{
#ifdef DEBUG
#ifdef DEBUGFILES
if (RunType==Debugging)
{
FSMakeFSSpec(Root.vRef,ComposeString(dbStr,"\pESInput %d",++dbCount),&temp);
FSpDupFile(&temp,&raw,True,False);
FSpGetFInfo(&temp,&info);
info.fdType = 'TEXT';
info.fdCreator = 'MPS ';
FSpSetFInfo(&temp,&info);
}
#endif
#endif
ZapHandle(*text);
Zero(addrList);
if (tlm->flags & (EMSF_BASIC_HEADERS+EMSF_ALL_HEADERS))
ETLBuildAddrList(PeteText(pte),nil,nil,&addrList,EMSF_ON_REQUEST);
err = CanTranslateFile(&(*TLFL)[tlm->module],TLF_ON_REQUEST,tlm->id,
tlMIME,&errorStr,&localErr,nil,&addrList,nil);
if (err==TLR_ABORTED) err = userCanceledErr;
if (!err || err==TLR_NOW)
{
err = MyTranslateFile(&(*TLFL)[tlm->module],TLF_ON_REQUEST,tlm->id,tlMIME,&raw,&localTLMIME,
&translated,nil,nil,&errorStr, &localErr,nil,
&addrList,nil, tlm->nameHandle);
if (err==TLR_ABORTED) err = userCanceledErr;
}
ETLDisposeAddrList(&addrList);
if (err)
{
if (err!=userCanceledErr && err!=EMSR_DATA_UNCHANGED) ETLError((*TLFL)[tlm->module].moduleDescription,ETL_CANT_TRANSLATE,errorStr,err,localErr);
ZapHandle(errorStr);
}
else
{
if (err=Snarf(&translated,text,0))
FileSystemError(ETL_CANT_TRANSLATE,translated.name,err);
#ifdef DEBUG
#ifdef DEBUGFILES
if (RunType==Debugging)
{
FSMakeFSSpec(Root.vRef,ComposeString(dbStr,"\pESOutput %d",dbCount),&temp);
FSpDupFile(&temp,&translated,True,False);
FSpGetFInfo(&temp,&info);
info.fdType = 'TEXT';
info.fdCreator = 'MPS ';
FSpSetFInfo(&temp,&info);
}
#endif
#endif
if (tlm->flags&TLF_GENERATES_MIME)
{
len = RemoveChar('\012',LDRef(*text),GetHandleSize_(*text));
UL(text);
SetHandleBig(*text,len);
bo = BodyOffset(*text);
BMD(**text+len,**text,len-bo);
SetHandleBig(*text,len-bo);
}
}
}
if (err) ZapHandle(*text);
ZapTLMIME(tlMIME);
ZapTLMIME(localTLMIME);
WipeSpec(&raw);
WipeSpec(&translated);
ZapHandle(errorStr);
ZapHandle(headers);
return(err);
}
/**********************************************************************
* PlainTextMIMEStuff - generate plaintext headers
**********************************************************************/
OSErr PlainTextMIMEStuff(emsMIMEHandle *tlMIME,Handle *headers)
{
emsMIMEHandle localTLMIME=nil;
Str255 scratch;
Str63 scratch2;
OSErr err;
if (tlMIME) *tlMIME = nil;
if (headers) *headers = nil;
if (!(err=NewMIME(&localTLMIME,headers?MIME_TEXT:MIME_APPLICATION,headers?MIME_PLAIN:MIME_MACTEXT)))
if (!(err=AddTLMIME(localTLMIME,TLMIME_PARAM,
GetRString(scratch,MIME_CHARSET),GetRString(scratch2,MIME_MAC))))
if (headers)
{
ComposeString(scratch,"\p%r: %r/%r; %r=%r\015\012\015\012",InterestHeadStrn+hContentType,
headers?MIME_TEXT:MIME_APPLICATION,
headers?MIME_PLAIN:MIME_MACTEXT,
MIME_CHARSET,MIME_MAC);
if (*headers=NuHTempBetter(*scratch))
BMD(scratch+1,**headers,*scratch);
else err = MemError();
}
if (err) ZapTLMIME(localTLMIME);
else if (tlMIME) *tlMIME = localTLMIME;
return(err);
}
/**********************************************************************
* ETLID - get the id value for a translator
**********************************************************************/
long ETLID(TLMHandle tl,short index)
{
short module;
short id;
id = (*tl)[index].id;
module = (*TLFL)[(*tl)[index].module].moduleID;
return((module<<16L)|id);
}
/**********************************************************************
* GetTransIcon - get a translator icon suite
**********************************************************************/
static OSErr GetTransIcon(TLFLPtr tlfl,long id,Handle *suite)
{
OSErr err = fnfErr;
*suite = nil;
if (UseParameterBlockStyleFunctions(tlfl->version))
{
emsTranslator transInfo;
Zero(transInfo);
SetSize(transInfo);
transInfo.id = id;
MightSwitch();
err = ems_translator_info(tlfl->instance,&transInfo);
AfterSwitch();
ZapHandle(transInfo.desc);
*suite = transInfo.icon;
}
else
{
MightSwitch();
err = tl_translator_info(tlfl->instance,id,nil,nil,nil,nil,suite);
AfterSwitch();
}
return(err);
}
/**********************************************************************
* ETLIDToFileIcon - turn a translator id into an icon suite
**********************************************************************/
OSErr ETLIDToFileIcon(long id,Handle *suite)
{
short mId = id>>16;
short tId = id&0xffff;
short i;
OSErr err = fnfErr;
if (TLFL)
{
for (i=HandleCount(TLFL);i--;)
if ((*TLFL)[i].moduleID==mId)
{
err = GetTransIcon(&(*TLFL)[i],tId,suite);
break;
}
}
return(err);
}
/**********************************************************************
* IsSystemComponent - is this a component in the System folder?
**********************************************************************/
static Boolean IsSystemComponent(Component comp)
{
short i;
if (ghSystemComponents)
{
for (i=HandleCount(ghSystemComponents);i--;)
if (comp == (*ghSystemComponents)[i])
return true;
}
return false;
}
/**********************************************************************
*
**********************************************************************/
void ETLCleanup(void)
{
short i;
// clean up importer plugin icons
if (TLImporterList)
for (i=HandleCount(TLImporterList);i--;)
DisposeIconSuite((*TLImporterList)[i].suite, true);
if (TLFL)
for (i=HandleCount(TLFL);i--;)
{
tlInstance instance = (*TLFL)[i].instance;
ComponentDescription info;
Component comp=nil;
Boolean fUnregister;
if (UseParameterBlockStyleFunctions((*TLFL)[i].version))
{
if (ComponentFunctionImplemented(instance,kems_plugin_finishRtn))
{
MightSwitch();
ems_plugin_finish(instance);
AfterSwitch();
}
}
else
{
if (ComponentFunctionImplemented(instance,ktl_module_finishRtn))
{
MightSwitch();
tl_module_finish(instance);
AfterSwitch();
}
}
// Unregister only if it is not a system component
fUnregister = !HaveTheDiseaseCalledOSX() && !(!GetComponentInfo((Component)instance,&info,nil,nil,nil) &&
(comp = FindNextComponent(comp, &info)) &&
IsSystemComponent(comp));
CloseComponent(instance);
if (fUnregister)
UnregisterComponent(comp);
}
}
/**********************************************************************
* ETLIdle - called from main event loop. Call plug-ins that want idle time
**********************************************************************/
void ETLIdle(long flags)
{
long thisTime;
short i;
emsIdleData idleData;
if (gIdleTimeCount && TLFL)
{
TLFLPtr pTLFL;
// Search for and call any plug-ins whose time has come
thisTime = (TickCount()*50)/3; // (ticks / 60 * 1000) Roughly in milliseconds
pTLFL = LDRef(TLFL);
for (i=HandleCount(TLFL);i--;pTLFL++)
{
if (pTLFL->idleTimeFreq && ((thisTime - pTLFL->lastIdleTime >= pTLFL->idleTimeFreq) || flags==EMSFIDLE_PRE_SEND))
{
// Call this one
idleData.flags = flags;
idleData.idleTimeFreq = &pTLFL->idleTimeFreq;
idleData.progress = TO_UPP_OR_NOT_TO_UPP(ETLProgress3);
MightSwitch();
ems_idle(pTLFL->instance,&idleData);
AfterSwitch();
pTLFL->lastIdleTime = thisTime;
}
}
UL(TLFL);
}
}
/**********************************************************************
* ETLEudoraModeNotification - called after loading plugins and after registration mode change.
**********************************************************************/
void ETLEudoraModeNotification(ModeEventEnum modeEvent, ModeTypeEnum newMode )
{
short i;
emsEudoraModeNotificationData modeNotificationData;
if (TLFL)
{
TLFLPtr pTLFL;
pTLFL = LDRef(TLFL);
for (i=HandleCount(TLFL);i--;pTLFL++)
{
if (ComponentFunctionImplemented(pTLFL->instance,kems_eudora_mode_notificationRtn))
{
// Call this one
modeNotificationData.size = sizeof(emsEudoraModeNotificationData);
modeNotificationData.modeEvent = EMS_ModeChanged;
modeNotificationData.isFullFeatureSet = newMode;
modeNotificationData.needsFullFeatureSet = EMS_ModeFree;
modeNotificationData.downgradeWasBeingUsed = false;
MightSwitch();
ems_eudora_mode_notification(pTLFL->instance,&modeNotificationData);
AfterSwitch();
pTLFL->modeNeeded = modeNotificationData.needsFullFeatureSet;
pTLFL->downgradeWasBeingUsed = modeNotificationData.downgradeWasBeingUsed;
}
}
UL(TLFL);
}
}
/**********************************************************************
* CanTranslateFile - determine if translator can act on this file
**********************************************************************/
static OSErr CanTranslateFile(TLFLPtr pTLFL,long context,short trans_id,
emsMIMEHandle in_mime, StringPtr **out_error,
long *out_code, StringHandle queuedProperties, emsHeaderDataP header, MessHandle messH)
{
long out_len; /* Place to return estimated length (unused) */
OSErr err;
tlInstance instance = pTLFL->instance;
Boolean pb = UseParameterBlockStyleFunctions(pTLFL->version);
if (pb)
{
emsTranslator trans; /* In: Translator Info */
emsDataFile inTransData; /* In: What to translate */
emsResultStatus transStatus; /* Out: Translations Status information */
Zero(trans);
SetSize(trans);
trans.id = trans_id;
trans.properties = queuedProperties;
Zero(inTransData);
SetSize(inTransData);
inTransData.context = context;
inTransData.mimeInfo = in_mime;
inTransData.header = header;
// inTransData.file (file parameter not used for can_translate)
Zero(transStatus);
SetSize(transStatus);
MightSwitch();
err = ems_can_translate(instance,&trans,&inTransData,&transStatus);
AfterSwitch();
if (transStatus.desc)
ZapHandle(transStatus.desc);
if (out_error)
*out_error = transStatus.error;
else
ZapHandle(transStatus.error);
if (out_code)
*out_code = transStatus.code;
HUnlock((Handle)in_mime);
}
else
{
tlMIMEtypeP tlMIME = DegradeMIME(in_mime);
tlAddrListHandle oldAddresses=nil;
if (messH)
ETLBuildOldAddrList(messH,&oldAddresses,ContextRequiresExpansion(context));
MightSwitch();
err = tl_can_translate_file(instance,context,trans_id,tlMIME,nil,oldAddresses,&out_len,out_error,out_code);
AfterSwitch();
DisposeOldTLMIME(tlMIME); // Dispose of copy
DisposeOldAddrList(oldAddresses);
}
return err;
}
/**********************************************************************
* MyTranslateFile - translate a file
**********************************************************************/
static OSErr MyTranslateFile(TLFLPtr pTLFL,long context,short trans_id,
emsMIMEHandle in_mime,FSSpec *in_file, emsMIMEHandle *out_mime,
FSSpec *out_file,Handle *out_icon,StringPtr **out_desc,StringPtr **out_error,
long *out_code, StringHandle queuedProperties, emsHeaderDataP header,
MessHandle messH, Handle translatorName)
{
OSErr err;
tlInstance instance = pTLFL->instance;
Boolean pb = UseParameterBlockStyleFunctions(pTLFL->version);
char hState = 0;
// OpenProgress();
PushProgress();
ProgressMessageR(kpTitle,TRANSLATING);
// right now we'll just set the subTitle to the name of the translator. we may want to include the module description?
hState = HGetState (translatorName);
HLock (translatorName);
ProgressMessage(kpSubTitle,*translatorName);
HSetState (translatorName, hState);
if (pb)
{
emsTranslator trans; /* In: Translator Info */
emsDataFile inTransData; /* In: What to translate */
emsDataFile outTransData; /* Out: Translation retult */
emsResultStatus transStatus; /* Out: Translations Status information */
Zero(trans);
SetSize(trans);
trans.id = trans_id;
trans.properties = queuedProperties;
Zero(inTransData);
SetSize(inTransData);
inTransData.context = context;
inTransData.mimeInfo = in_mime;
inTransData.header = header;
inTransData.file = *in_file;
Zero(outTransData);
SetSize(outTransData);
outTransData.mimeInfo = nil;
outTransData.file = *out_file;
Zero(transStatus);
SetSize(transStatus);
MightSwitch();
err = ems_translate_file(instance,&trans,&inTransData, TO_UPP_OR_NOT_TO_UPP(ETLProgress3), &outTransData,&transStatus);
AfterSwitch();
if (out_desc)
*out_desc = transStatus.desc;
else
ZapHandle(transStatus.desc);
if (out_error)
*out_error = transStatus.error;
else
ZapHandle(transStatus.error);
if (out_code)
*out_code = transStatus.code;
if (out_mime)
*out_mime = outTransData.mimeInfo;
else
DisposeTLMIME(outTransData.mimeInfo);
}
else
{
tlMIMEtypeP outMIME = nil;
tlMIMEtypeP tlMIME = DegradeMIME(in_mime);
tlAddrListHandle oldAddresses=nil;
if (messH)
ETLBuildOldAddrList(messH,&oldAddresses,ContextRequiresExpansion(context));
MightSwitch();
err = tl_translate_file(instance,context,trans_id,tlMIME,in_file,oldAddresses,TO_UPP_OR_NOT_TO_UPP(ETLProgress3),&outMIME,
out_file,out_icon,out_desc,out_error,out_code);
AfterSwitch();
DisposeOldTLMIME(tlMIME); // Dispose of copy
DisposeOldAddrList(oldAddresses);
*out_mime = UpgradeMIME(outMIME);
}
PopProgress(false);
// CloseProgress ();
return err;
}
/**********************************************************************
* ETLSpecial - call a transator's special menu item
**********************************************************************/
OSErr ETLSpecial(short item)
{
emsMenu mInfo;
OSErr err;
Zero(mInfo);
SetSize(mInfo);
mInfo.id = (*TLSpecialList)[item-1].id;
MightSwitch();
err = ems_special_hook((*TLFL)[(*TLSpecialList)[item-1].module].instance,&mInfo);
AfterSwitch();
return(err);
}
/**********************************************************************
* ETLSpecialEnableBasedOnMode - enable transator's special menu items
* based on whether or not they work in the reg mode that Eudora is in
**********************************************************************/
void ETLEnableSpecialItems()
{
MenuHandle hMenu = GetMHandle(SPECIAL_MENU);
short i, n, menuItem;
if (hMenu && TLSpecialList && *TLSpecialList && (n=HandleCount(TLSpecialList)))
{
for (i=0;i<n;i++)
{
menuItem = i+SPECIAL_BAR4_ITEM+1;
if ((*TLFL)[(*TLSpecialList)[i].module].modeNeeded > GetCurrentPayMode ())
{
DisableMenuItemWithProOnlyIcon(hMenu, menuItem);
}
else
{
SetMenuItemIconHandle(hMenu, menuItem, kMenuNoIcon, nil);
EnableItem(hMenu, menuItem);
}
}
}
}
/**********************************************************************
* ETLAttach - call an attachment translator
**********************************************************************/
OSErr ETLAttach(short item,MyWindowPtr win)
{
emsMenu mInfo;
OSErr err;
long numFiles=0;
FSSpec spec;
emsDataFileH dfs=nil;
short i;
Zero(mInfo);
SetSize(mInfo);
mInfo.id = (*TLAttachList)[item-1].id;
if (err=MakeAttSubFolder(Win2MessH(win),SumOf(Win2MessH(win))->uidHash,&spec)) return(err);
MightSwitch();
err=ems_attacher_hook((*TLFL)[(*TLAttachList)[item-1].module].instance,&mInfo,&spec,&numFiles,&dfs);
AfterSwitch();
if (err) return(err);
if (dfs)
{
ASSERT(numFiles==HandleCount(dfs));
for (i=0;i<numFiles;i++)
{
spec = (*dfs)[i].file;
CompAttachSpec(win,&spec);
}
ZapHandle(dfs);
}
return(noErr);
}
/**********************************************************************
* ETLDoSettings - call translators for settings
**********************************************************************/
OSErr ETLDoSettings(short item)
{
OSErr err;
short module = (*TLSettingList)[item-1].module;
TLFuncList tlfl = (*TLFL)[module];
short t;
if (UseOldMailConfig(tlfl.version))
{
emsPre7MailConfig mailConfig;
ETLFillMailConfig(&mailConfig, nil, true);
MightSwitch();
err = ems_plugin_config(tlfl.instance,&mailConfig);
AfterSwitch();
ETLEmptyMailConfig(&mailConfig);
}
else
{
emsCallBack callbacks;
emsMailConfig mailConfig;
ETLFillMailConfig(&mailConfig, &callbacks, false);
MightSwitch();
err = ems_plugin_config(tlfl.instance,&mailConfig);
AfterSwitch();
ETLEmptyMailConfig(&mailConfig);
}
// Call ems_translator_info for each translator to see if flags, icons, etc. have changed
for (t=0;t<tlfl.tCount;t++)
{
TLMaster tlm;
Zero(tlm);
if (UseParameterBlockStyleFunctions(tlfl.version))
{
emsTranslator transInfo;
Zero(transInfo);
SetSize(transInfo);
transInfo.id = t+1;
MightSwitch();
err = ems_translator_info(tlfl.instance,&transInfo);
AfterSwitch();
tlm.type = transInfo.type;
tlm.flags = transInfo.flags;
tlm.nameHandle = transInfo.desc;
tlm.suite = transInfo.icon;
}
// v1
else
{
MightSwitch();
err = tl_translator_info(tlfl.instance,t+1,&tlm.type,nil,&tlm.flags,&tlm.nameHandle,&tlm.suite);
AfterSwitch();
}
if (!err)
{
Handle oldText=nil,suite=nil;
TLMPtr pTLM;
short n;
gTranslatorFlags |= tlm.flags;
// Search for translator in SelList and update fields
for(n=HandleCount(TLSelList),pTLM=*TLSelList+n-1;n--;pTLM--)
if (pTLM->module==module && pTLM->id==t+1)
{
oldText = pTLM->nameHandle;
pTLM->nameHandle = tlm.nameHandle;
pTLM->flags = tlm.flags;
pTLM->type = tlm.type;
if (!suite && tlm.suite)
{
suite = pTLM->suite;
DupIconSuite(tlm.suite,&suite,suite!=nil); // dup the suite, right into the old suite if we have one
DisposeIconSuite(tlm.suite,true); // only dup once
tlm.suite = nil;
pTLM=*TLSelList+n; // update our silly pointer, since might have moved after DisposeIconSuite above
}
pTLM->suite = suite;
break;
}
// Search for translator in Q4List and update fields
for(n=HandleCount(TLQ4List),pTLM=*TLQ4List+n-1;n--;pTLM--)
if (pTLM->module==module && pTLM->id==t+1)
{
if (!oldText) oldText = pTLM->nameHandle;
pTLM->nameHandle = tlm.nameHandle;
pTLM->flags = tlm.flags;
pTLM->type = tlm.type;
if (!suite && tlm.suite)
{
suite = pTLM->suite;
DupIconSuite(tlm.suite,&suite,suite!=nil); // dup the suite, right into the old suite if we have one
DisposeIconSuite(tlm.suite,true); // only dup once
tlm.suite = nil;
pTLM=*TLSelList+n; // update our silly pointer, since might have moved after DisposeIconSuite above
}
pTLM->suite = suite;
break;
}
if (oldText) DisposeHandle(oldText);
}
}
return(err);
}
/**********************************************************************
* QueuedProperties - allow plugin to store properties
**********************************************************************/
OSErr QueuedProperties(short which, long *selected, StringHandle *pProperties,Boolean fDefaultOn)
{
emsTranslator trans;
OSErr err = noErr;
#define pTLFL (&(*TLFL)[(*TLQ4List)[which].module])
if (UseParameterBlockStyleFunctions(pTLFL->version) && ComponentFunctionImplemented(pTLFL->instance,kems_queued_propertiesRtn))
{
Zero(trans);
SetSize(trans);
trans.id = pTLFL->moduleID;
trans.properties = *pProperties;
if (fDefaultOn)
trans.flags = 1; // Indicate that the translator is default on instead of clicked on by the user
MightSwitch();
err = ems_queued_properties(pTLFL->instance,&trans,selected);
AfterSwitch();
//better to leak than crash... if (*pProperties && trans.properties!=*pProperties) ZapHandle(*pProperties); // kill the old one if not still used
if (trans.properties)
{
if (err || !*selected)
ZapHandle(trans.properties); // Translator really should not have returned this handle
else
*pProperties = trans.properties; // Return properties
}
}
else ZapHandle(*pProperties); // get rid of copy of properties
return err;
}
/**********************************************************************
* ETLSelect - user clicked on plugin icon, allow plugin to store properties
**********************************************************************/
OSErr ETLSelect(short which, Boolean selecting, MessHandle messH)
{
long selected;
StringHandle properties;
OSErr result;
properties = selecting ? nil :
// Deselecting. Get any existing queued properties
GetQueuedProperties(messH,ETLIconToID(which));
if (properties) properties = DupHandle(properties); // protect our handle
selected = selecting;
result = QueuedProperties(which, &selected, &properties, false);
if (selecting)
{
if (selected)
AddMessTranslator(messH,which,properties);
}
else
{
RemoveMessTranslator(messH,which);
if (selected)
AddMessTranslator(messH,which,properties);
}
return result;
}
/**********************************************************************
* ETLGetPluginFolderSpec - return filespec for a folder in plugin filters folder
**********************************************************************/
OSErr ETLGetPluginFolderSpec(FSSpec *spec,short nameId)
{
Str255 s;
OSErr err;
if (!(err = FSMakeFSSpec(ItemsFolder.vRef,ItemsFolder.dirId,GetRString(s,PLUGINS_FOLDER),spec)))
{
IsAlias(spec,spec);
if (nameId)
{
err = FSMakeFSSpec(spec->vRefNum,SpecDirId(spec),GetRString(s,nameId),spec);
IsAlias(spec,spec);
}
}
return err;
}
/**********************************************************************
* UpgradeMIME - Convert from older mime structure in place
**********************************************************************/
static emsMIMEHandle UpgradeMIME(tlMIMEtypeP inMIME)
{
emsMIMEHandle outMIME = (emsMIMEHandle)inMIME;
if (inMIME)
{
emsMIMEtype tempMIME;
tlMIMEtype *pInMIME;
tlMIMEParamP hParam;
// Convert MIME info to newer data structure
SetHandleSize((Handle)inMIME,sizeof(emsMIMEtype)); // Need to enlarge for larger structure
if (MemError())
return nil; // Error, don't return anything
pInMIME = *inMIME;
Zero(tempMIME);
SetSize(tempMIME);
BMD(pInMIME->mime_version,tempMIME.mimeVersion,sizeof(tempMIME.mimeVersion));
BMD(pInMIME->mime_type,tempMIME.mimeType,sizeof(tempMIME.mimeType));
BMD(pInMIME->sub_type,tempMIME.subType,sizeof(tempMIME.subType));
hParam = pInMIME->params;
tempMIME.params = (emsMIMEparamH)hParam;
BMD(&tempMIME,*inMIME,sizeof(tempMIME));
// Now convert any parameters to newer data structure
while (hParam)
{
tlMIMEparam *pParam;
emsMIMEparam tempParam;
SetHandleSize((Handle)hParam,sizeof(emsMIMEparam)); // Need to enlarge for larger structure
if (MemError())
return nil; // Error, don't return anything
pParam = *hParam;
SetSize(tempParam);
BMD(pParam->name,tempParam.name,sizeof(tempParam.name));
tempParam.value = pParam->value;
hParam = pParam->next;
tempParam.next = (emsMIMEparamH)hParam;
BMD(&tempParam,pParam,sizeof(tempParam));
}
}
return outMIME;
}
/* Junk Stuff */
OSErr ETLScoreJunk ( TLMPtr thePlugin,
emsTranslatorP transInfo, /* In: Translator Info */
emsJunkInfoP junkInfo, /* In: Junk information */
emsMessageInfoP messageInfo, /* In: Message to score */
emsJunkScoreP junkScore, /* Out: Junk score */
emsResultStatusP junkStatus /* Out: Status information */
) {
return ems_score_junk ( (*TLFL)[ thePlugin->module].instance, transInfo, junkInfo, messageInfo, junkScore, junkStatus );
}
/* Junk Stuff */
OSErr ETLMarkJunk ( TLMPtr thePlugin,
emsTranslatorP transInfo, /* In: Translator Info */
emsJunkInfoP junkInfo, /* In: Junk information */
emsMessageInfoP messageInfo, /* In: Message to score */
emsJunkScoreP junkScore, /* Out: Junk score */
emsResultStatusP junkStatus /* Out: Status information */
) {
return ems_user_mark_junk ( (*TLFL)[ thePlugin->module].instance, transInfo, junkInfo, messageInfo, junkScore, junkStatus );
}
/**********************************************************************
* DegradeMIMEParam - Convert to older mime paramater structure. Returns a copy.
**********************************************************************/
static tlMIMEParamP DegradeMIMEParam(emsMIMEparamH hParam)
{
tlMIMEParamP hResult = nil;
if (hParam && (hResult = NuHandle(sizeof(tlMIMEparam))))
{
BMD((*hParam)->name,(*hResult)->name,sizeof((*hResult)->name));
(*hResult)->value = (*hParam)->value; // We didn't make a copy of this so don't dispose of it!!!
(*hResult)->next = DegradeMIMEParam((*hParam)->next); // Recurse
}
return hResult;
}
/**********************************************************************
* DegradeMIME - Convert to older mime structure. Returns a copy.
**********************************************************************/
static tlMIMEtypeP DegradeMIME(emsMIMEHandle inMIME)
{
tlMIMEtypeP outMIME = nil;
if (inMIME && (outMIME = NuHandle(sizeof(tlMIMEtype))))
{
// Convert MIME info to older data structure
BMD((*inMIME)->mimeVersion,(*outMIME)->mime_version,sizeof((*outMIME)->mime_version));
BMD((*inMIME)->mimeType,(*outMIME)->mime_type,sizeof((*outMIME)->mime_type));
BMD((*inMIME)->subType,(*outMIME)->sub_type,sizeof((*outMIME)->sub_type));
(*outMIME)->params = DegradeMIMEParam((*inMIME)->params);
}
return outMIME;
}
/**********************************************************************
* GetQueuedProperties - Find queued properties from message
**********************************************************************/
static StringHandle GetQueuedProperties(MessHandle messH,long id)
{
TransInfoHandle translators = (*messH)->hTranslators;
short i;
if (translators)
for (i=HandleCount(translators);i--;)
if ((*translators)[i].id==id)
return (*translators)[i].properties;
return nil;
}
/************************************************************************
* Modeless EMSAPI stuff
************************************************************************/
/************************************************************************
* IsPlugwindow - is something a plugin window?
************************************************************************/
Boolean IsPlugwindow(WindowPtr theWindow)
{
return(theWindow && GetWindowKind(theWindow)==EMS_PW_WINDOWKIND);
}
/************************************************************************
* IsModalPlugwindow - is something a plugin window that wants to
* be non-blocking modal?
************************************************************************/
Boolean IsModalPlugwindow(WindowPtr theWindow)
{
Boolean isModalPlugwindow = false;
if (theWindow && GetWindowKind(theWindow)==EMS_PW_WINDOWKIND)
{
long refCon = GetWRefCon(theWindow);
if (refCon != 0)
{
emsPlugwindowDataP wdPtr = *(emsPlugwindowDataH)refCon;
// If the plugin is new enough then check the emsPlugwindowData
if (wdPtr->size > (&wdPtr->isDialogLayer - wdPtr))
isModalPlugwindow = wdPtr->isDialogLayer;
}
}
return isModalPlugwindow;
}
/************************************************************************
* IsNonModalPlugwindow - is something a plugin window that wants to
* be normal (i.e. not non-blocking modal)?
************************************************************************/
Boolean IsNonModalPlugwindow(WindowPtr theWindow)
{
return (IsPlugwindow(theWindow) && !IsModalPlugwindow(theWindow));
}
/************************************************************************
* PlugwindowEventFilter - filter an event for a plugin window
************************************************************************/
Boolean PlugwindowEventFilter(EventRecord *event)
{
emsPlugwindowData wd;
short module;
emsPlugwindowEvent ed;
WindowPtr theWindow = nil;
Boolean result=true;
switch(event->what)
{
case updateEvt:
case activateEvt:
theWindow = Event2Window(event);
break;
case mouseDown:
case mouseUp:
// If modal window is frontmost and if it's not a dialog modal window, then bail
FindWindow(event->where,&theWindow);
if ( ModalWindow && ((ModalWindow != theWindow) || !IsModalPlugwindow(theWindow)) )
return(true);
break;
}
if (!theWindow) theWindow = MyFrontNonFloatingWindow();
if (IsPlugwindow(theWindow))
{
long refCon = GetWRefCon(theWindow);
if (refCon != 0)
{
wd = **(emsPlugwindowDataH)refCon;
SetSize(wd);
if (PluginIDToIndex(wd.pluginID,&module))
{
Zero(ed);
SetSize(ed);
ed.nativeEvent = event;
//Dprintf("\pem %x win %x wd.nativeWindow %x pID %d m %d;g",event->message,win,wd.nativeWindow,wd.pluginID,module);
result = 0!=ems_plugwindow_event((*TLFL)[module].instance,&wd,&ed);
}
}
}
return(result);
}
/************************************************************************
* PlugwindowEnable - grab flags for plugwindow enabling
************************************************************************/
void PlugwindowEnable(WindowPtr theWindow,long *flags)
{
long refCon = GetWRefCon(theWindow);
if (refCon != 0)
{
emsPlugwindowData wd = **(emsPlugwindowDataH)refCon;
short module;
emsMenuData md;
*flags = 0;
if (PluginIDToIndex(wd.pluginID,&module))
{
Zero(md);
SetSize(md);
SetSize(wd);
ems_plugwindow_menu_enable((*TLFL)[module].instance,&wd,&md);
*flags = md.menuMask;
}
}
}
/************************************************************************
* PlugwindowMenu - do a menu command for a plugin window
************************************************************************/
Boolean PlugwindowMenu(WindowPtr theWindow,long select)
{
long refCon = GetWRefCon(theWindow);
if (refCon != 0)
{
emsPlugwindowData wd = **(emsPlugwindowDataH)refCon;
short module;
emsMenuData md;
Zero(md);
SetSize(md);
switch(select)
{
case (FILE_MENU<<16)|FILE_CLOSE_ITEM: md.menuMask = EMS_MENU_FILE_CLOSE; break;
case (FILE_MENU<<16)|FILE_SAVE_ITEM: md.menuMask = EMS_MENU_FILE_SAVE; break;
case (EDIT_MENU<<16)|EDIT_UNDO_ITEM: md.menuMask = EMS_MENU_EDIT_UNDO; break;
case (EDIT_MENU<<16)|EDIT_CUT_ITEM: md.menuMask = EMS_MENU_EDIT_CUT; break;
case (EDIT_MENU<<16)|EDIT_COPY_ITEM: md.menuMask = EMS_MENU_EDIT_COPY; break;
case (EDIT_MENU<<16)|EDIT_PASTE_ITEM: md.menuMask = EMS_MENU_EDIT_PASTE; break;
case (EDIT_MENU<<16)|EDIT_CLEAR_ITEM: md.menuMask = EMS_MENU_EDIT_CLEAR; break;
case (EDIT_MENU<<16)|EDIT_SELECT_ITEM: md.menuMask = EMS_MENU_EDIT_SELECTALL; break;
default: return(false);
}
if (PluginIDToIndex(wd.pluginID,&module))
{
SetSize(wd);
return(!ems_plugwindow_menu((*TLFL)[module].instance,&wd,&md));
}
}
return(false);
}
/************************************************************************
* PlugwindowClose - close a plug-in window
************************************************************************/
Boolean PlugwindowClose(WindowPtr theWindow)
{
Boolean windowWasClosed = false;
long refCon = GetWRefCon(theWindow);
if (refCon != 0)
{
emsPlugwindowData wd = **(emsPlugwindowDataH)refCon;
short module;
if (PluginIDToIndex(wd.pluginID,&module))
{
SetSize(wd);
windowWasClosed = !ems_plugwindow_close((*TLFL)[module].instance,&wd);
}
else
{
DisposeWindow(theWindow);
windowWasClosed = true;
}
}
else
{
DisposeWindow(theWindow);
windowWasClosed = true;
}
// PopModalWindow and setting lastHilitedWinWP to 0 if necessary
// should have already been done in ETLPlugwindowUnRegister.
// Check to see if we need to do either of these now in case the
// plugin didn't call ETLPlugwindowUnRegister, or we had to close the
// window ourselves.
if (IsModalPlugwindow(theWindow) && (theWindow == ModalWindow))
PopModalWindow();
#ifdef FLOAT_WIN
if (theWindow == lastHilitedWinWP) lastHilitedWinWP = 0;
#endif //FLOAT_WIN
return (windowWasClosed);
}
/************************************************************************
* PlugwindowDrag - drag tracking in a plugwindow
************************************************************************/
OSErr PlugwindowDrag(WindowPtr theWindow,DragTrackingMessage message,DragReference drag)
{
long refCon = GetWRefCon(theWindow);
if (refCon != 0)
{
emsPlugwindowData wd = **(emsPlugwindowDataH)refCon;
emsPlugwindowDragData pd;
short module;
if (PluginIDToIndex(wd.pluginID,&module))
{
SetSize(wd);
Zero(pd);
SetSize(pd);
pd.drag = drag;
pd.message = message;
return(ems_plugwindow_drag((*TLFL)[module].instance,&wd,&pd));
}
}
return(dragNotAcceptedErr);
}
/************************************************************************
* PlugwindowSendFakeEvent - only call for plugin windows
************************************************************************/
void PlugwindowSendFakeEvent(WindowPtr theWindow, UInt32 message, EventKind what, EventModifiers modifiers, Point * where)
{
short module;
emsPlugwindowEvent ed;
EventRecord event;
long refCon = GetWRefCon(theWindow);
if (refCon != 0)
{
emsPlugwindowData wd = **(emsPlugwindowDataH)refCon;
SetSize(wd);
if (PluginIDToIndex(wd.pluginID,&module))
{
Zero(event);
event.what = what;
event.message = message;
event.modifiers = modifiers;
if (where)
event.where = *where;
Zero(ed);
SetSize(ed);
ed.nativeEvent = &event;
ems_plugwindow_event((*TLFL)[module].instance,&wd,&ed);
}
}
}
/************************************************************************
* PlugwindowActivate -
************************************************************************/
void PlugwindowActivate(WindowPtr theWindow, Boolean active)
{
if (IsPlugwindow(theWindow))
{
#ifdef FLOAT_WIN
HiliteWindow(theWindow,active);
#endif //FLOAT_WIN
PlugwindowSendFakeEvent(theWindow, (long)theWindow, activateEvt, active ? activeFlag : 0, nil);
}
}
/************************************************************************
* PlugwindowUpdate - if a window is a plugin window, update it
************************************************************************/
void PlugwindowUpdate(WindowPtr theWindow)
{
if (IsPlugwindow(theWindow))
PlugwindowSendFakeEvent(theWindow, (long)theWindow, updateEvt, 0, nil);
}
/***************************************************************************
* ETLCreateMailBox - Callback to create a mailbox, but not for the importers
***************************************************************************/
static pascal short ETLCreateMailBox(emsCreateMailBoxDataP makeMailboxData)
{
FSSpec folderSpec;
FSSpec createdSpec;
OSErr err = noErr;
SLDisable();
SetSize(*makeMailboxData);
// Where do we make it?
if (makeMailboxData->parentFolder)
{
err = SimpleResolveAlias(makeMailboxData->parentFolder,&folderSpec);
if (!err) folderSpec.parID = SpecDirId(&folderSpec);
}
else
{
folderSpec.vRefNum = MailRoot.vRef;
folderSpec.parID = MailRoot.dirId;
}
if (!err)
{
// What do we call it?
err = FSMakeFSSpec(folderSpec.vRefNum,folderSpec.parID,makeMailboxData->name,&createdSpec);
// die if something went wrong
if (!err)
{
// It exists, check to see if it's what the caller expected
Boolean isFolder, boolJunk;
err = ResolveAliasFile(&createdSpec, True, &isFolder, &boolJunk);
if ( !err && (isFolder != makeMailboxData->createFolder) )
err = dupFNErr;
}
else if (err==fnfErr)
{
// Make it
if (err=BadMailboxName(&createdSpec, makeMailboxData->createFolder)) err = bdNamErr;
if (!err)
{
// let the menus and mailboxes window know about it
BuildBoxMenus();
MBTickle(nil,nil);
// Make an alias to it
FSMakeFSSpec(MailRoot.vRef, MailRoot.dirId, "", &folderSpec);
NewAlias(&folderSpec, &createdSpec, &makeMailboxData->mailboxOrFolder);
}
}
}
SLEnable();
// We be done
return (err);
}
/***************************************************************************
* ETLIsInAddressBook - Callback to create a mailbox, but not for the importers
***************************************************************************/
static pascal short ETLIsInAddressBook(emsIsInAddressBookDataP makeMailboxData)
{
// To do: Marshall - please implement.
return unimpErr;
}
/************************************************************************
* Import Plugin support
************************************************************************/
/**********************************************************************
* ETLImport - call the importer with the spcified ID
**********************************************************************/
OSErr ETLImport(long id, ImportOperationEnum what, void *params, void *results)
{
OSErr err = noErr;
emsImporterData data;
TLMPtr importer;
tlInstance instance;
//
// find the importer
//
if (TLImporterList)
{
importer = &((*TLImporterList)[id]);
if (importer)
{
instance = (&(*TLFL)[importer->module])->instance;
if (!(err=!ComponentFunctionImplemented(instance,kems_importer_hookRtn)))
{
//
// make the call
//
SetSize(data);
data.what = what;
data.params = params;
data.results = results;
PushProgress();
err = ems_importer_hook(instance,&data);
PopProgress(false);
}
}
else // no importer with that id
err = TLR_CANT_TRANS;
}
else // no importer translator handle
err = TLR_CANT_TRANS;
return (err);
}
/***************************************************************************
* ETLQueryImporters - check importer plugins and see what can be imported
***************************************************************************/
OSErr ETLQueryImporters(ImportAccountInfoH *results, long id, Boolean search)
{
OSErr err = noErr;
short i, j;
if (TLImporterList)
{
// Loop through all importers and call the Query function
for (i=HandleCount(TLImporterList);i--;)
{
if ((id == kUnspecifiedImportPluginId) || (id == i))
{
err = ETLImport(i, search?EMS_IMPORT_Query:EMS_IMPORT_Name_Query, (void *)TO_UPP_OR_NOT_TO_UPP(ETLProgress3), (void *)(results));
if (err) ImportError(i, kImportSetupErr, kImportQueryError, err, __LINE__);
// go through and fill in the id field of al new results
for (j=HandleCount(*results);j--;)
if ((**results)[j].id == -1)
(**results)[j].id = i;
}
}
}
else // no importer translator handle
{
err = TLR_CANT_TRANS;
ImportError(kUnspecifiedImportPluginId, kImportSetupErr, kImportMemError, err, __LINE__);
}
return (err);
}
/***************************************************************************
* GetImporterAppIcon - return a handle to the impoter's app icon
***************************************************************************/
Handle GetImporterAppIcon(long id)
{
Handle suite = nil;
if (TLImporterList)
if (id <= HandleCount(TLImporterList))
suite = (*TLImporterList)[id].suite;
return (suite);
}
/***************************************************************************
* GetImporterName - return the name of an importer
***************************************************************************/
void GetImporterName(long id, Str255 name)
{
name[0] = 0;
if (TLImporterList)
if (id <= HandleCount(TLImporterList))
PCopy(name,*(*TLImporterList)[id].nameHandle);
}
/************************************************************************
* ETLImportSignatures - Import an account's signatures
************************************************************************/
OSErr ETLImportSignatures(ImportAccountInfoP account)
{
ImportSignaturesDataS makeSigData;
Zero(makeSigData);
SetSize(makeSigData);
makeSigData.importSpec = account->importSpec;
makeSigData.makeSig = TO_UPP_OR_NOT_TO_UPP(ETLMakeSig);
makeSigData.progress = TO_UPP_OR_NOT_TO_UPP(ETLProgress3);
return (ETLImport(account->id, EMS_IMPORT_Signatures, &makeSigData, nil));
}
/************************************************************************
* ETLImportAddresses - Import an account's address book(s)
************************************************************************/
OSErr ETLImportAddresses(ImportAccountInfoP account)
{
ImportAddressDataS addressImportData;
Zero(addressImportData);
SetSize(addressImportData);
addressImportData.importSpec = account->importSpec;
PCopy(addressImportData.accountName, account->accountName);
addressImportData.makeAddressBook = TO_UPP_OR_NOT_TO_UPP(ETLMakeAddressBook);
addressImportData.makeABEntry = TO_UPP_OR_NOT_TO_UPP(ETLMakeABEntry);
addressImportData.progress = TO_UPP_OR_NOT_TO_UPP(ETLProgress3);
return (ETLImport(account->id, EMS_IMPORT_Addresses, &addressImportData, nil));
}
/************************************************************************
* ETLImportMail - Import an account's messages and mailboxes
************************************************************************/
OSErr ETLImportMail(ImportAccountInfoP account)
{
ImportMailDataS mailImportData;
Zero(mailImportData);
SetSize(mailImportData);
mailImportData.importSpec = account->importSpec;
PCopy(mailImportData.accountName, account->accountName);
mailImportData.makeMailbox = TO_UPP_OR_NOT_TO_UPP(ETLMakeMailbox);
mailImportData.makeOutMess = TO_UPP_OR_NOT_TO_UPP(ETLMakeOutMess);
mailImportData.makeMessage = TO_UPP_OR_NOT_TO_UPP(ETLMakeMessage);
mailImportData.progress = TO_UPP_OR_NOT_TO_UPP(ETLProgress3);
mailImportData.importMBox = TO_UPP_OR_NOT_TO_UPP(ETLImportMbox);
return (ETLImport(account->id, EMS_IMPORT_Mail, &mailImportData, nil));
}
/************************************************************************
* ETLImportSettings - Import an account's settings
************************************************************************/
OSErr ETLImportSettings(ImportAccountInfoP account, ImportPersDataH *persData)
{
OSErr err = noErr;
*persData = NuHandle(0L);
err = MemError();
if ((err == noErr) && *persData && **persData)
{
err = ETLImport(account->id, EMS_IMPORT_Settings, &(account->importSpec), persData);
if (err != noErr)
{
// an error occurred importing settings information
ImportError(account->id, kImportSettingsErr, kImportSettingsError, err=eofErr, __LINE__);
ZapHandle(*persData);
}
}
else
{
// a memory related error occurred.
ImportError(kUnspecifiedImportPluginId, kImportSettingsErr, kImportMemError, err, __LINE__);
}
return (err);
}
/***************************************************************************
* ETLMakeSig - Callback to create a signature file
***************************************************************************/
static pascal short ETLMakeSig(emsMakeSigDataP makeSigData)
{
short returnMe;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
returnMe = (ImportMakeNewSigCalback(makeSigData->name, makeSigData->sigText));
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return returnMe;
}
/***************************************************************************
* ETLImportMbox - Callback to import mail from an mbox file
***************************************************************************/
static pascal short ETLImportMbox(emsImportMboxDataP importMBoxData)
{
short returnMe;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
returnMe = ImportMboxCallback ( &importMBoxData->sourceMBox, &importMBoxData->boxSpec );
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return returnMe;
}
/***************************************************************************
* ETLMakeAddressBook - Callback to create an address book file
***************************************************************************/
static pascal short ETLMakeAddressBook(emsMakeAddressBookDataP makeAddressBookData)
{
short returnMe;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
returnMe = (ImportMakeAddressBookCallback(makeAddressBookData->name));
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return returnMe;
}
/***************************************************************************
* ETLMakeABEntry - Callback to create an address book entry
***************************************************************************/
static pascal short ETLMakeABEntry(emsMakeABEntryDataP makeABEntryData)
{
short returnMe;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
returnMe = (ImportMakeABEntryCallback(makeABEntryData->which, makeABEntryData->isGroup, makeABEntryData->nickName, makeABEntryData->addresses, makeABEntryData->notes));
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return returnMe;
}
/***************************************************************************
* ETLMakeMailbox - Callback to create a mailbox
***************************************************************************/
static pascal short ETLMakeMailbox(emsMakeMailboxDataP makeMailboxData)
{
short returnMe;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
returnMe = (ImportMakeMailboxCallback(makeMailboxData->command, &(makeMailboxData->boxSpec), makeMailboxData->isFolder, makeMailboxData->noSelect));
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return returnMe;
}
/***************************************************************************
* ETLMakeOutMess - Callback to create an outgoing message
***************************************************************************/
static pascal short ETLMakeOutMess(emsMakeOutMessDataP makeOutMessData)
{
short returnMe;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
returnMe = (ImportMakeOutMessCallback(makeOutMessData));
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return returnMe;
}
/***************************************************************************
* ETLMakeMessage - Callback to create an outgoing message
***************************************************************************/
static pascal short ETLMakeMessage(emsMakeMessageDataP makeMessageData)
{
short returnMe;
SLDisable(); // Spotlight doesn't like emsapi callbacks, alas
returnMe = (ImportMessageCallback(makeMessageData->ref, makeMessageData->offset, makeMessageData->len, makeMessageData->state, makeMessageData->attachments, &(makeMessageData->boxSpec)));
SLEnable(); // Spotlight doesn't like emsapi callbacks, alas
return returnMe;
}
#endif
#if TARGET_RT_MAC_CFM
/* For old-style calls to components */
enum {
uppCallComponentProcInfo = kPascalStackBased
| RESULT_SIZE(kFourByteCode)
| STACK_ROUTINE_PARAMETER(1, kFourByteCode)
};
/* This global takes the routine parameters for each component function call */
tl_ComponentParameters tl_GCP;
/* Routine to put a copy of the component params on the stack and calls
CallComponentUPP */
ComponentResult Calltl_ComponentFunction(tl_ComponentParameters params)
{
return CallComponentDispatch(/*tl_GCP.params.ems_translate_file.globals,*/&params);
}
/* This global takes the routine parameters for each component function call */
ems_ComponentParameters ems_GCP;
/* Routine to put a copy of the component params on the stack and calls
CallComponentUPP */
ComponentResult Callems_ComponentFunction(ems_ComponentParameters params)
{
return CallComponentDispatch(/*ems_GCP.params.ems_translate_file.globals,*/&params);
}
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink