зеркало из https://github.com/mozilla/gecko-dev.git
985 строки
27 KiB
C++
985 строки
27 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 ***** */
|
|
|
|
|
|
#include "nsAEUtils.h"
|
|
#include "nsAETokens.h"
|
|
#include "nsAECoreClass.h"
|
|
|
|
#include "nsAEGenericClass.h"
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
AEGenericClass
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEGenericClass::AEGenericClass(DescType classType, DescType containerClass)
|
|
: mClass(classType)
|
|
, mContainerClass(containerClass)
|
|
, mItemFromContainerAccessor(nil)
|
|
{
|
|
|
|
// Window from null accessor used by the entire window hierarchy
|
|
mItemFromContainerAccessor = NewOSLAccessorUPP(AEGenericClass::ItemFromContainerAccessor);
|
|
ThrowIfNil(mItemFromContainerAccessor);
|
|
|
|
OSErr err;
|
|
err = AEInstallObjectAccessor(mClass, containerClass,
|
|
mItemFromContainerAccessor,
|
|
(long)this,
|
|
false);
|
|
|
|
// although items of a given class can't contain other items of the same class,
|
|
// we need this accessor to support formRelativePostion,
|
|
// which sends us one item as a "container" and asks us to find
|
|
// either the item before or after that item
|
|
err = AEInstallObjectAccessor(mClass, mClass,
|
|
mItemFromContainerAccessor,
|
|
(long)this,
|
|
false);
|
|
ThrowIfOSErr(err);
|
|
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
~AEGenericClass
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEGenericClass::~AEGenericClass()
|
|
{
|
|
if (mItemFromContainerAccessor)
|
|
DisposeOSLAccessorUPP(mItemFromContainerAccessor);
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
DispatchEvent
|
|
|
|
Handles all OSL messages that this object should handle
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::DispatchEvent(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
OSErr err = noErr;
|
|
|
|
AEEventID eventID;
|
|
OSType typeCode;
|
|
Size actualSize = 0L;
|
|
|
|
// Get the event ID
|
|
err = AEGetAttributePtr(appleEvent, keyEventIDAttr,
|
|
typeType,
|
|
&typeCode,
|
|
(Ptr)&eventID,
|
|
sizeof(eventID),
|
|
&actualSize);
|
|
ThrowIfOSErr(err);
|
|
|
|
try
|
|
{
|
|
switch (eventID)
|
|
{
|
|
case kAEClone:
|
|
HandleDuplicate(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEClose:
|
|
HandleClose(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAECountElements:
|
|
HandleCount(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAECreateElement:
|
|
HandleMake(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEDelete:
|
|
HandleDelete(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEDoObjectsExist:
|
|
HandleExists(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEGetData:
|
|
HandleGetData(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEGetDataSize:
|
|
HandleDataSize(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEMove:
|
|
HandleMove(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEOpen: // == kAEOpenDocuments
|
|
HandleOpen(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEPrint:
|
|
HandlePrint(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEOpenApplication:
|
|
HandleRun(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEReopenApplication:
|
|
HandleReOpen(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAEQuitApplication:
|
|
HandleQuit(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAESave:
|
|
HandleSave(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAESetData:
|
|
HandleSetData(token, appleEvent, reply);
|
|
break;
|
|
|
|
// MT-NW suite
|
|
case kAEExtract:
|
|
HandleExtract(token, appleEvent, reply);
|
|
break;
|
|
|
|
case kAESendMessage:
|
|
HandleSendMessage(token, appleEvent, reply);
|
|
break;
|
|
|
|
default:
|
|
err = errAEEventNotHandled;
|
|
break;
|
|
}
|
|
}
|
|
catch (OSErr catchErr)
|
|
{
|
|
PutReplyErrorNumber(reply, catchErr);
|
|
throw;
|
|
}
|
|
catch ( ... )
|
|
{
|
|
PutReplyErrorNumber(reply, paramErr);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetProperty
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::GetProperty( DescType desiredClass,
|
|
const AEDesc* containerToken,
|
|
DescType containerClass,
|
|
DescType keyForm,
|
|
const AEDesc* keyData,
|
|
AEDesc* resultToken)
|
|
{
|
|
|
|
// call the base class utility method, which calls back up to the object
|
|
GetPropertyFromListOrObject(desiredClass, containerToken, containerClass, keyForm, keyData, resultToken);
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
ItemFromContainerAccessor
|
|
|
|
Callback for getting an item from its container
|
|
----------------------------------------------------------------------------*/
|
|
pascal OSErr AEGenericClass::ItemFromContainerAccessor( DescType desiredClass, // cWindow
|
|
const AEDesc* containerToken, // null container
|
|
DescType containerClass, // cApplication
|
|
DescType keyForm,
|
|
const AEDesc* keyData,
|
|
AEDesc* resultToken, // specified window is returned in result
|
|
long refCon)
|
|
{
|
|
AEGenericClass* itemClass = reinterpret_cast<AEGenericClass *>(refCon);
|
|
if (!itemClass) return paramErr;
|
|
|
|
OSErr err = noErr;
|
|
|
|
try
|
|
{
|
|
itemClass->GetItemFromContainer(desiredClass, containerToken, containerClass, keyForm, keyData, resultToken);
|
|
}
|
|
catch(OSErr catchErr)
|
|
{
|
|
err = catchErr;
|
|
}
|
|
catch(...)
|
|
{
|
|
err = paramErr;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleClose
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleClose(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleCount
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleCount(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ConstAETokenDesc tokenDesc(token);
|
|
long numberOfObjects = 0;
|
|
DescType objectClass;
|
|
OSErr err = noErr;
|
|
|
|
if (!reply->dataHandle)
|
|
return;
|
|
|
|
// Get the class of object that we will count
|
|
err = GetObjectClassFromAppleEvent(appleEvent, &objectClass);
|
|
ThrowIfOSErr(err);
|
|
|
|
err = CheckForUnusedParameters(appleEvent);
|
|
ThrowIfOSErr(err);
|
|
|
|
if (AEListUtils::TokenContainsTokenList(token))
|
|
{
|
|
err = AECountItems(token, &numberOfObjects);
|
|
ThrowIfOSErr(err);
|
|
|
|
}
|
|
else
|
|
{
|
|
CountObjects(objectClass, tokenDesc.GetDispatchClass(), token, &numberOfObjects);
|
|
}
|
|
|
|
err = AEPutParamPtr(reply, keyAEResult,
|
|
typeLongInteger,
|
|
(Ptr)&numberOfObjects,
|
|
sizeof(long));
|
|
ThrowIfOSErr(err);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleGetData
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleGetData(AEDesc *tokenOrTokenList, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
OSErr err = noErr;
|
|
StAEDesc data;
|
|
StAEDesc desiredTypes;
|
|
|
|
(void)AEGetParamDesc(appleEvent, keyAERequestedType, typeAEList, &desiredTypes);
|
|
|
|
GetDataFromListOrObject(tokenOrTokenList, &desiredTypes, &data);
|
|
|
|
if (reply->descriptorType != typeNull)
|
|
{
|
|
err = AEPutKeyDesc(reply, keyDirectObject, &data);
|
|
ThrowIfOSErr(err);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleSetData
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleSetData(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
SetDataForListOrObject(token, appleEvent, reply);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleDataSize
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleDataSize(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleDelete
|
|
|
|
All attempts to delete an empty list are handled here
|
|
Application contains documents and windows, and they can't be deleted
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleDelete(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleDuplicate
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleDuplicate(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleExists
|
|
|
|
If <anObject> exists...
|
|
The AEResolve() function in AERCoreSuite.c will already have filtered
|
|
out all cases where the object did not exist, so this function should
|
|
always return TRUE.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleExists(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
OSErr err;
|
|
Boolean foundIt = true;
|
|
|
|
err = AEPutParamPtr(reply,
|
|
keyAEResult,
|
|
typeBoolean,
|
|
(Ptr)&foundIt,
|
|
sizeof(Boolean));
|
|
|
|
ThrowIfOSErr(err);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleMake
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleMake(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
DescType insertionPos = typeNull;
|
|
OSErr err = noErr;
|
|
|
|
StAEDesc insertionLoc;
|
|
StAEDesc objectSpec;
|
|
|
|
// For Create Element, the object specifier is contained in
|
|
// a typeInsertionLoc record instead of in a direct parameter.
|
|
// We coerce the insertionLoc record into an AERecord so we can extract the fields.
|
|
// Notice that this is a REQUIRED parameter, but we give it a default behavior
|
|
// by creating a new element at beginning of the first document
|
|
|
|
err = ::AEGetParamDesc(appleEvent, // Extract as a AERecord
|
|
keyAEInsertHere,
|
|
typeAERecord,
|
|
&insertionLoc);
|
|
if (err == errAEDescNotFound)
|
|
{
|
|
insertionPos = kAEBeginning;
|
|
err = noErr;
|
|
}
|
|
else if (err == noErr)
|
|
{
|
|
// Get the enumerated insertion location (at end, in front, before, after, replace.)
|
|
|
|
OSType typeCode;
|
|
Size actualSize;
|
|
err = ::AEGetKeyPtr(&insertionLoc,
|
|
keyAEPosition, // insertion location
|
|
typeEnumeration,
|
|
&typeCode,
|
|
(Ptr)&insertionPos,
|
|
sizeof(insertionPos),
|
|
&actualSize);
|
|
|
|
// Extract and resolve the object specifier from the insertion location record.
|
|
// In a case like "make new rectangle before rectangle 1 of document 1",
|
|
// the ospec will resolve to "rectangle 1 of document 1"
|
|
|
|
err = ::AEGetKeyDesc(&insertionLoc,
|
|
keyAEObject,
|
|
typeWildCard,
|
|
&objectSpec);
|
|
}
|
|
|
|
// if there was a object specifier in the insertion location (eg, "before rectangle 1 of document 1"),
|
|
// then we call AEResolve() to get a token for it,
|
|
// Otherwise, is was something like "at end" or "at beginning", which is also OK,
|
|
// then deal with it correctly later.
|
|
if (objectSpec.descriptorType == typeNull)
|
|
{
|
|
::AEDisposeDesc(token); // destroy it's old representation, token will now be null descriptor
|
|
}
|
|
else
|
|
{
|
|
err = ::AEResolve(&objectSpec,
|
|
kAEIDoMinimum,
|
|
token); // token will contain info about the object to insert before, after, etc.
|
|
ThrowIfOSErr(err);
|
|
}
|
|
|
|
// Extract the optional parameters from the AppleEvent
|
|
|
|
// ----- [with data ....] -----
|
|
|
|
StAEDesc withData;
|
|
const AEDesc* withDataPtr = nil;
|
|
|
|
err = ::AEGetParamDesc(appleEvent,
|
|
keyAEData,
|
|
typeWildCard,
|
|
&withData);
|
|
if (err == errAEDescNotFound)
|
|
err = noErr;
|
|
else
|
|
{
|
|
ThrowIfOSErr(err);
|
|
withDataPtr = &withData;
|
|
}
|
|
|
|
// ----- [with properties {property: value, ...}] -----
|
|
StAEDesc withProperties;
|
|
const AEDesc* withPropertiesPtr = nil;
|
|
err = AEGetParamDesc(appleEvent,
|
|
keyAEPropData,
|
|
typeWildCard,
|
|
&withProperties);
|
|
|
|
if (err == errAEDescNotFound)
|
|
err = noErr;
|
|
else
|
|
{
|
|
ThrowIfOSErr(err);
|
|
withPropertiesPtr = &withProperties;
|
|
}
|
|
|
|
// Finally, use the token and other parameters to create & initialize the object
|
|
MakeNewObject(insertionPos, token, withDataPtr, withPropertiesPtr, reply);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleMove
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleMove(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleOpen
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleOpen(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleReOpen
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleReOpen(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleRun
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleRun(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandlePrint
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandlePrint(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleQuit
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleQuit(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleSave
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleSave(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleExtract
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleExtract(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleSendMessage
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::HandleSendMessage(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CompareObjects
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::CompareObjects( DescType comparisonOperator,
|
|
const AEDesc * object,
|
|
const AEDesc * descriptorOrObject,
|
|
Boolean * result)
|
|
{
|
|
ThrowOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CountObjects
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::CountObjects( DescType desiredType,
|
|
DescType containerClass,
|
|
const AEDesc * container,
|
|
long * result)
|
|
{
|
|
ThrowOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetDataFromListOrObject
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
|
|
void AEGenericClass::GetDataFromListOrObject(const AEDesc *tokenOrTokenList, AEDesc *desiredTypes, AEDesc *data)
|
|
{
|
|
if (AEListUtils::TokenContainsTokenList(tokenOrTokenList) == false)
|
|
{
|
|
GetDataFromObject(tokenOrTokenList, desiredTypes, data);
|
|
}
|
|
else
|
|
{
|
|
ThrowIfOSErr(AECreateList(nil, 0, false, data));
|
|
GetDataFromList(tokenOrTokenList, desiredTypes, data);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetDataFromListOrObject
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
|
|
void AEGenericClass::SetDataForListOrObject(const AEDesc *tokenOrTokenList, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
StAEDesc data;
|
|
|
|
switch (tokenOrTokenList->descriptorType)
|
|
{
|
|
case typeAEList:
|
|
{
|
|
AECoreClass::GetAECoreHandler()->GetEventKeyDataParameter(appleEvent, typeWildCard, &data);
|
|
SetDataForList(tokenOrTokenList, &data);
|
|
}
|
|
break;
|
|
|
|
case cProperty:
|
|
{
|
|
ConstAETokenDesc tokenDesc(tokenOrTokenList);
|
|
DescType propertyCode = tokenDesc.GetPropertyCode();
|
|
//DescType objectClass = tokenDesc.GetObjectClass();
|
|
|
|
if (CanSetProperty(propertyCode))
|
|
{
|
|
AECoreClass::GetAECoreHandler()->GetEventKeyDataParameter(appleEvent, GetKeyEventDataAs(propertyCode), &data);
|
|
SetDataForObject(tokenOrTokenList, &data);
|
|
}
|
|
else
|
|
{
|
|
ThrowIfOSErr(errAENotModifiable);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ThrowIfOSErr(errAENotModifiable);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetDataFromList
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::GetDataFromList(const AEDesc *srcList, AEDesc *desiredTypes, AEDesc *dstList)
|
|
{
|
|
OSErr err;
|
|
long itemNum;
|
|
long numItems;
|
|
DescType keyword;
|
|
StAEDesc srcItem;
|
|
StAEDesc dstItem;
|
|
|
|
err = AECountItems((AEDescList*)srcList, &numItems);
|
|
ThrowIfOSErr(err);
|
|
|
|
for (itemNum = 1; itemNum <= numItems; itemNum++)
|
|
{
|
|
err = AEGetNthDesc(srcList, itemNum, typeWildCard, &keyword, &srcItem);
|
|
ThrowIfOSErr(err);
|
|
|
|
if (AEListUtils::TokenContainsTokenList(&srcItem) == false)
|
|
{
|
|
GetDataFromObject(&srcItem, desiredTypes, &dstItem); // Get data from single item
|
|
}
|
|
else
|
|
{
|
|
ThrowIfOSErr(AECreateList(nil, 0, false, &dstItem));
|
|
GetDataFromList(&srcItem, desiredTypes, &dstItem);
|
|
}
|
|
err = AEPutDesc(dstList, itemNum, &dstItem);
|
|
ThrowIfOSErr(err);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetDataFromObject
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::GetDataFromObject(const AEDesc *token, AEDesc *desiredTypes, AEDesc *data)
|
|
{
|
|
ConstAETokenDesc tokenDesc(token);
|
|
DescType propertyCode = tokenDesc.GetPropertyCode();
|
|
OSErr err = noErr;
|
|
|
|
switch (propertyCode)
|
|
{
|
|
case pContents:
|
|
case typeNull:
|
|
// must mean contents. Make a self specifier.
|
|
CreateSpecifier(token, data);
|
|
break;
|
|
|
|
default:
|
|
err = errAECantSupplyType;
|
|
break;
|
|
}
|
|
|
|
ThrowIfOSErr(err);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
SetDataForList
|
|
|
|
Given a token that contains a list of cWindow tokens,
|
|
walk the list recursively to set the data for each token in the list
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::SetDataForList(const AEDesc *token, AEDesc *data)
|
|
{
|
|
OSErr err;
|
|
|
|
if (AEListUtils::TokenContainsTokenList(token) == false)
|
|
{
|
|
SetDataForObject(token, data);
|
|
}
|
|
else
|
|
{
|
|
long numItems;
|
|
long itemNum;
|
|
err = AECountItems((AEDescList*)token, &numItems);
|
|
ThrowIfOSErr(err);
|
|
|
|
for (itemNum = 1; itemNum <= numItems; itemNum++)
|
|
{
|
|
StAEDesc tempToken;
|
|
AEKeyword keyword;
|
|
|
|
err = AEGetNthDesc((AEDescList*)token, itemNum, typeWildCard, &keyword, &tempToken);
|
|
ThrowIfOSErr(err);
|
|
|
|
if (AEListUtils::TokenContainsTokenList(&tempToken) == false)
|
|
{
|
|
SetDataForObject(&tempToken, data); // Set data from single item
|
|
}
|
|
else
|
|
{
|
|
SetDataForList(&tempToken, data); // Recurse sublist
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CanGetProperty
|
|
|
|
----------------------------------------------------------------------------*/
|
|
DescType AEGenericClass::GetKeyEventDataAs(DescType propertyCode)
|
|
{
|
|
return typeWildCard;
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CanGetProperty
|
|
|
|
----------------------------------------------------------------------------*/
|
|
Boolean AEGenericClass::CanGetProperty(DescType propertyCode)
|
|
{
|
|
Boolean canGet = false;
|
|
|
|
switch (propertyCode)
|
|
{
|
|
case pContents:
|
|
canGet = true;
|
|
break;
|
|
}
|
|
return canGet;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CanSetProperty
|
|
|
|
----------------------------------------------------------------------------*/
|
|
Boolean AEGenericClass::CanSetProperty(DescType propertyCode)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CreateSpecifier
|
|
|
|
Subclasses should not need to override this. It
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::CreateSpecifier(const AEDesc *token, AEDesc *outSpecifier)
|
|
{
|
|
CreateSelfSpecifier(token, outSpecifier);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetContainerSpecifier
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::GetContainerSpecifier(const AEDesc *token, AEDesc *outContainerSpecifier)
|
|
{
|
|
outContainerSpecifier->descriptorType = typeNull;
|
|
outContainerSpecifier->dataHandle = nil;
|
|
|
|
AEDispatchHandler* handler = AECoreClass::GetDispatchHandlerForClass(mContainerClass);
|
|
if (handler)
|
|
{
|
|
handler->CreateSelfSpecifier(token, outContainerSpecifier);
|
|
}
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetPropertyFromListOrObject
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::GetPropertyFromListOrObject( DescType desiredClass,
|
|
const AEDesc* containerToken,
|
|
DescType containerClass,
|
|
DescType keyForm,
|
|
const AEDesc* keyData,
|
|
AEDesc* resultToken)
|
|
{
|
|
if (AEListUtils::TokenContainsTokenList((AEDescList*)containerToken) == false)
|
|
{
|
|
GetPropertyFromObject(desiredClass, containerToken, containerClass, keyForm, keyData, resultToken);
|
|
}
|
|
else
|
|
{
|
|
OSErr err = AECreateList(nil, 0, false, resultToken);
|
|
ThrowIfOSErr(err);
|
|
|
|
GetPropertyFromList(desiredClass, containerToken, containerClass, keyForm, keyData, resultToken);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetPropertyFromList
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::GetPropertyFromList( DescType desiredClass,
|
|
const AEDesc* containerToken,
|
|
DescType containerClass,
|
|
DescType keyForm,
|
|
const AEDesc* keyData,
|
|
AEDesc* resultToken)
|
|
{
|
|
OSErr err = noErr;
|
|
long itemNum;
|
|
long numItems;
|
|
DescType keyword;
|
|
|
|
err = AECountItems((AEDescList*)containerToken, &numItems);
|
|
ThrowIfOSErr(err);
|
|
|
|
for (itemNum = 1; itemNum <= numItems; itemNum++)
|
|
{
|
|
StAEDesc srcItem;
|
|
StAEDesc dstItem;
|
|
|
|
err = AEGetNthDesc(containerToken, itemNum, typeWildCard, &keyword, &srcItem);
|
|
ThrowIfOSErr(err);
|
|
|
|
if (AEListUtils::TokenContainsTokenList(&srcItem) == false)
|
|
{
|
|
GetPropertyFromObject(desiredClass, &srcItem, containerClass, keyForm, keyData, &dstItem);
|
|
}
|
|
else
|
|
{
|
|
err = AECreateList(nil, 0, false, &dstItem);
|
|
ThrowIfOSErr(err);
|
|
|
|
GetPropertyFromList(desiredClass, &srcItem, containerClass, keyForm, keyData, &dstItem);
|
|
}
|
|
|
|
err = AEPutDesc(resultToken, itemNum, &dstItem);
|
|
ThrowIfOSErr(err);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetPropertyFromObject
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::GetPropertyFromObject( DescType desiredType,
|
|
const AEDesc* containerToken,
|
|
DescType containerClass,
|
|
DescType keyForm,
|
|
const AEDesc* keyData,
|
|
AEDesc* resultToken)
|
|
{
|
|
OSErr err;
|
|
DescType requestedProperty;
|
|
|
|
err = AEDuplicateDesc(containerToken, resultToken);
|
|
ThrowIfOSErr(err);
|
|
|
|
requestedProperty = **(DescType**)(keyData->dataHandle);
|
|
|
|
if (requestedProperty == kAEAll || requestedProperty == keyAEProperties)
|
|
requestedProperty = pProperties;
|
|
|
|
if (CanGetProperty(requestedProperty) || CanSetProperty(requestedProperty))
|
|
{
|
|
AETokenDesc resultTokenDesc(resultToken);
|
|
resultToken->descriptorType = desiredType;
|
|
resultTokenDesc.SetPropertyCode(requestedProperty);
|
|
}
|
|
else
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
MakeNewObject
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEGenericClass::MakeNewObject( const DescType insertionPosition,
|
|
const AEDesc* token,
|
|
const AEDesc* ptrToWithData,
|
|
const AEDesc* ptrToWithProperties,
|
|
AppleEvent* reply)
|
|
{
|
|
ThrowOSErr(errAEEventNotHandled);
|
|
}
|
|
|