gecko-dev/xpfe/bootstrap/appleevents/nsAEUtils.h

309 строки
8.7 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Simon Fraser <sfraser@netscape.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef __AEUTILS__
#define __AEUTILS__
#include <MacTypes.h>
#include <AppleEvents.h>
#include <AERegistry.h>
#include <ASRegistry.h>
#include <AEObjects.h>
#include <FinderRegistry.h>
#include <Files.h>
#include <Errors.h>
#include <Aliases.h>
#include <MacWindows.h>
#include "nsAEDefs.h"
#include "nsMacUtils.h"
#define ThrowIfNil(a) do { if (a == nil) { throw((OSErr)memFullErr); } } while (0)
#define ThrowErrIfNil(a, err) do { if (a == nil) { OSErr theErr = (err); throw((OSErr)theErr); } } while (0)
#define ThrowErrIfTrue(a, err) do { if (a) { OSErr theErr = (err); throw((OSErr)theErr); } } while (0)
#define ThrowIfOSErr(err) do { OSErr theErr = (err); if (theErr != noErr) { throw((OSErr)theErr); } } while (0)
#define ThrowOSErr(err) do { throw((OSErr)err); } while (0)
#define ThrowNoErr() do { throw((OSErr)noErr); } while (0)
#define pObjectType 'pObT'
// Windows
#define pTitle 'pTit'
#define pIsModeless 'pNMo'
#define pIsMovableModal 'pMMo'
#define pIsSuspended 'pSus'
#define pIsPalette 'pPal'
#define pIsDialog 'pDlg'
#define pLocation 'pLcn' // the upper left corner of the object's bounding box
// Application
#define pFreeMemory 'pMem'
#define pTicks 'pTic'
// data given to a spawned thread for suspending and resuming Apple Events.
// there should be one of these per event.
typedef struct TThreadAEInfo
{
AppleEvent mAppleEvent;
AppleEvent mReply;
SInt32 mSuspendCount; // how many suspend calls we have
Boolean mGotEventData;
} TThreadAEInfo, *TThreadAEInfoPtr;
#ifdef __cplusplus
extern "C" {
#endif
OSErr CreateAliasAEDesc(AliasHandle theAlias, AEDesc *ioDesc);
OSErr GetTextFromAEDesc(const AEDesc *inDesc, Handle *outTextHandle);
OSErr CreateThreadAEInfo(const AppleEvent *event, AppleEvent *reply, TThreadAEInfoPtr *outThreadAEInfo);
void DisposeThreadAEInfo(TThreadAEInfo *threadAEInfo);
OSErr SuspendThreadAE(TThreadAEInfo *threadAEInfo);
OSErr ResumeThreadAE(TThreadAEInfo *threadAEInfo, OSErr threadError);
#if !TARGET_CARBON
OSErr AEGetDescData(const AEDesc *theAEDesc, void * dataPtr, Size maximumSize);
Size AEGetDescDataSize(const AEDesc *theAEDesc);
OSErr AEReplaceDescData(DescType typeCode, const void *dataPtr, Size dataSize, AEDesc* theAEDesc);
#endif /* TARGET_CARBON */
#ifdef __cplusplus
}
#endif
// a stack-based, exception safely class for an AEDesc
class StAEDesc: public AEDesc
{
public:
StAEDesc()
{
descriptorType = typeNull;
dataHandle = nil;
}
StAEDesc(const StAEDesc& rhs); // copy constructor
~StAEDesc()
{
::AEDisposeDesc(this);
}
void Clear()
{
::AEDisposeDesc(this);
descriptorType = typeNull;
dataHandle = nil;
}
void CheckDataType(DescType expectedType)
{
if (descriptorType != expectedType)
ThrowOSErr(errAEWrongDataType);
}
StAEDesc& operator= (const StAEDesc&rhs); // throws OSErrs
Size GetDataSize()
{
return AEGetDescDataSize(this);
}
Boolean GetBoolean();
SInt16 GetShort();
SInt32 GetLong();
DescType GetEnumType();
void GetRect(Rect& outRect);
void GetRGBColor(RGBColor& outColor);
void GetLongDateTime(LongDateTime& outDateTime);
void GetFileSpec(FSSpec &outFileSpec);
void GetCString(char *outString, short maxLen);
void GetPString(Str255 outString);
Handle GetTextHandle();
};
class StEventSuspender
{
public:
// use deleteData = false when calling threads, which take ownership of the TThreadAEInfoPtr
StEventSuspender(const AppleEvent *appleEvent, AppleEvent *reply, Boolean deleteData = true);
~StEventSuspender();
void SetDeleteData(Boolean deleteData) { mDeleteData = deleteData; }
void SuspendEvent();
void ResumeEvent();
TThreadAEInfoPtr GetThreadAEInfo() { return mThreadAEInfo; }
protected:
TThreadAEInfoPtr mThreadAEInfo;
Boolean mDeleteData;
};
class StHandleHolder
{
public:
StHandleHolder(Handle inHandle = nil); // takes ownership of the handle
~StHandleHolder();
StHandleHolder& operator=(Handle rhs);
void Lock();
void Unlock();
Handle GetHandle() { return mHandle; }
Size GetHandleSize() { return (mHandle) ? ::GetHandleSize(mHandle) : 0; }
Ptr GetPtr() { return (mHandle) ? *mHandle : nil; }
class getter
{
public:
getter(StHandleHolder& handleHolder)
: mHandleHolder(handleHolder)
, mHandle(nil)
{
}
~getter()
{
mHandleHolder = mHandle;
}
operator Handle*()
{
return &mHandle;
}
private:
StHandleHolder& mHandleHolder;
Handle mHandle;
};
// it is risky to define operator&, but, hey, we know what we're doing.
getter operator &()
{
return getter(*this);
}
// Does the same as operator&, but more explicitly.
getter AssignHandle()
{
return getter(*this);
}
protected:
Handle mHandle;
SInt32 mLockCount;
UInt8 mOldHandleState;
};
class AEListUtils
{
public:
static Boolean TokenContainsTokenList(const AEDesc *token) { return (token->descriptorType == typeAEList); }
static OSErr GetFirstNonListToken(const AEDesc *token, AEDesc *result);
static OSErr FlattenAEList(AEDescList *deepList, AEDescList *flatList);
};
// simple iterator for AEDescs which may be lists. Is NOT safe to the list changing under it.
// also, it does not handle nested lists.
class AEListIterator
{
public:
AEListIterator(AEDesc *token);
~AEListIterator() {}
Boolean Next(AEDesc* outItemData); // data should be deleted by the caller.
SInt32 GetNumItems() { return mNumItems; }
protected:
AEDesc mListToken; // we don't own this.
SInt32 mNumItems;
SInt32 mCurItem;
Boolean mIsListDesc;
};
OSErr DescToPString(const AEDesc* desc, Str255 aPString, short maxLength);
OSErr DescToCString(const AEDesc* desc, CStr255 aPString, short maxLength);
OSErr DescToDescType(const AEDesc *desc, DescType *descType);
OSErr DescToBoolean(const AEDesc* desc, Boolean* aBoolean);
OSErr DescToFixed(const AEDesc* desc, Fixed* aFixed);
OSErr DescToFloat(const AEDesc* desc, float* aFloat);
OSErr DescToLong(const AEDesc* desc, long* aLong);
OSErr DescToRGBColor(const AEDesc* desc, RGBColor* aRGBColor);
OSErr DescToShort(const AEDesc* desc, short* aShort);
OSErr DescToTextHandle(const AEDesc* desc, Handle *text);
OSErr DescToRect(const AEDesc* desc, Rect* aRect);
OSErr DescToPoint(const AEDesc* desc, Point* aPoint);
OSErr CheckForUnusedParameters(const AppleEvent* appleEvent);
OSErr PutReplyErrorNumber(AppleEvent* reply, long errorNumber);
OSErr PutReplyErrorMessage(AppleEvent* reply, char *message);
OSErr GetObjectClassFromAppleEvent(const AppleEvent *appleEvent, DescType *objectClass);
OSErr NormalizeAbsoluteIndex(const AEDesc *keyData, long *index, long maxIndex, Boolean *isAllItems);
OSErr ProcessFormRange(AEDesc *keyData, AEDesc *start, AEDesc *stop);
#endif /* __AEUTILS__ */