mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-07-05 08:50:11 +02:00
989 lines
27 KiB
C++
989 lines
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 <string.h>
|
|
#include <AEPackObject.h>
|
|
|
|
#include "nsMemory.h"
|
|
#include "nsWindowUtils.h"
|
|
|
|
#include "nsAppleEvents.h"
|
|
|
|
#include "nsAEUtils.h"
|
|
#include "nsAETokens.h"
|
|
#include "nsAECoreClass.h"
|
|
#include "nsAEApplicationClass.h"
|
|
|
|
#include "nsAEWindowClass.h"
|
|
|
|
#include "nsGfxUtils.h"
|
|
|
|
using namespace nsWindowUtils;
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetNumItems
|
|
|
|
----------------------------------------------------------------------------*/
|
|
UInt32 AEWindowIterator::GetNumItems(const AEDesc* containerToken)
|
|
{
|
|
return CountWindowsOfKind(mWindowKind);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetNamedItemReference
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEClassIterator::ItemRef AEWindowIterator::GetNamedItemReference(const AEDesc* containerToken, const char *itemName)
|
|
{
|
|
WindowPtr wind;
|
|
wind = GetNamedOrFrontmostWindow(mWindowKind, itemName);
|
|
return (wind) ? (ItemRef)wind : kNoItemRef;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetIndexedItemReference
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEClassIterator::ItemRef AEWindowIterator::GetIndexedItemReference(const AEDesc* containerToken, TAEListIndex itemIndex)
|
|
{
|
|
WindowPtr wind = GetIndexedWindowOfKind(mWindowKind, itemIndex);
|
|
return (wind) ? (ItemRef)wind : kNoItemRef;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetNamedItemID
|
|
|
|
Window refs and IDs are the same for windows
|
|
----------------------------------------------------------------------------*/
|
|
AEClassIterator::ItemID AEWindowIterator::GetNamedItemID(const AEDesc* containerToken, const char *itemName)
|
|
{
|
|
WindowPtr wind;
|
|
wind = GetNamedOrFrontmostWindow(mWindowKind, itemName);
|
|
return (wind) ? (ItemRef)wind : kNoItemID;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetIndexFromItemID
|
|
|
|
----------------------------------------------------------------------------*/
|
|
TAEListIndex AEWindowIterator::GetIndexFromItemID(const AEDesc* containerToken, ItemID itemID)
|
|
{
|
|
return GetWindowIndex(mWindowKind, (WindowPtr)itemID);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetIndexedItemID
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEClassIterator::ItemID AEWindowIterator::GetIndexedItemID(const AEDesc* containerToken, TAEListIndex itemIndex)
|
|
{
|
|
WindowPtr wind = GetIndexedWindowOfKind(mWindowKind, itemIndex);
|
|
return (wind) ? (ItemRef)wind : kNoItemID;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetIndexedItemName
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowIterator::GetIndexedItemName(const AEDesc* containerToken, TAEListIndex itemIndex, char *outName, long maxLen)
|
|
{
|
|
WindowPtr wind = GetIndexedWindowOfKind(mWindowKind, itemIndex);
|
|
GetCleanedWindowName(wind, outName, maxLen);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetIDFromReference
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEClassIterator::ItemID AEWindowIterator::GetIDFromReference(const AEDesc* containerToken, ItemRef itemRef)
|
|
{
|
|
return (ItemID)itemRef;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetReferenceFromID
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEClassIterator::ItemRef AEWindowIterator::GetReferenceFromID(const AEDesc* containerToken, ItemID itemID)
|
|
{
|
|
return (ItemRef)itemID;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetItemIDFromToken
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEClassIterator::ItemID AEWindowIterator::GetItemIDFromToken(const AEDesc* token)
|
|
{
|
|
ConstAETokenDesc tokenDesc(token);
|
|
return (ItemID)tokenDesc.GetWindowPtr();
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
SetItemIDInCoreToken
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowIterator::SetItemIDInCoreToken(const AEDesc* containerToken, CoreTokenRecord* tokenRecord, ItemID itemID)
|
|
{
|
|
tokenRecord->window = (WindowPtr)itemID;
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
AEWindowClass
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEWindowClass::AEWindowClass(DescType classType, TWindowKind windowKind)
|
|
: AEGenericClass(classType, typeNull)
|
|
, mWindowKind(windowKind)
|
|
, mDocumentAccessor(nil)
|
|
{
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
~AEWindowClass
|
|
|
|
----------------------------------------------------------------------------*/
|
|
AEWindowClass::~AEWindowClass()
|
|
{
|
|
if (mDocumentAccessor)
|
|
DisposeOSLAccessorUPP(mDocumentAccessor);
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetItemFromContainer
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::GetItemFromContainer( DescType desiredClass,
|
|
const AEDesc* containerToken,
|
|
DescType containerClass,
|
|
DescType keyForm,
|
|
const AEDesc* keyData,
|
|
AEDesc* resultToken)
|
|
{
|
|
AEWindowIterator windowIterator(GetClass(), GetThisWindowKind());
|
|
windowIterator.GetItemFromContainer(desiredClass, containerToken, containerClass, keyForm, keyData, resultToken);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CompareObjects
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::CompareObjects( DescType comparisonOperator,
|
|
const AEDesc * object1,
|
|
const AEDesc * object2,
|
|
Boolean * result)
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CountObjects
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::CountObjects( DescType desiredType,
|
|
DescType containerClass,
|
|
const AEDesc * container,
|
|
long * result)
|
|
{
|
|
*result = CountWindows(mWindowKind);
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleClose
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandleClose(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
OSErr err = noErr;
|
|
|
|
StAEDesc saving;
|
|
StAEDesc savingIn;
|
|
|
|
AEDesc *ptrToSaving = nil;
|
|
AEDesc *ptrToSavingIn = nil;
|
|
|
|
// Extract the [saving yes/no/ask] optional parameter, if present
|
|
err = AEGetParamDesc(appleEvent, keyAESaveOptions, typeWildCard, &saving);
|
|
|
|
if (err == noErr)
|
|
ptrToSaving = &saving;
|
|
else if (err == errAEDescNotFound)
|
|
err = noErr;
|
|
else
|
|
ThrowIfOSErr(err);
|
|
|
|
// Extract the [saving in <alias>] optional parameter, if present
|
|
err = AEGetParamDesc(appleEvent, keyAEFile, typeFSS, &savingIn);
|
|
|
|
if (err == noErr)
|
|
ptrToSavingIn = &savingIn;
|
|
else if (err == errAEDescNotFound)
|
|
err = noErr;
|
|
else
|
|
ThrowIfOSErr(err);
|
|
|
|
// Check for any required parameters we may have missed
|
|
err = CheckForUnusedParameters(appleEvent);
|
|
ThrowIfOSErr(err);
|
|
|
|
// Now, do the application-related work
|
|
if (AEListUtils::TokenContainsTokenList(token))
|
|
{
|
|
long numItems;
|
|
long itemNum;
|
|
AEKeyword keyword;
|
|
|
|
err = AECountItems(token, &numItems);
|
|
ThrowIfOSErr(err);
|
|
|
|
if (numItems > 0)
|
|
{
|
|
for (itemNum = 1; itemNum <= numItems; itemNum++)
|
|
{
|
|
StAEDesc windowToken;
|
|
err = AEGetNthDesc(token, itemNum, typeWildCard, &keyword, &windowToken);
|
|
if (err != noErr) break;
|
|
|
|
//AECoreClass::sAECoreHandler->GetDocumentClass()->CloseWindowSaving(&windowToken, ptrToSaving, ptrToSavingIn);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//AECoreClass::sAECoreHandler->GetDocumentClass()->CloseWindowSaving(token, ptrToSaving, ptrToSavingIn);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleDataSize
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::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 AEWindowClass::HandleDelete(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleDuplicate
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandleDuplicate(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleExists
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandleExists(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleMake
|
|
|
|
We can't make generic windows.
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandleMake(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleMove
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandleMove(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleOpen
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandleOpen(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandlePrint
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandlePrint(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleQuit
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandleQuit(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
HandleSave
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::HandleSave(AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
|
|
{
|
|
ThrowIfOSErr(errAEEventNotHandled);
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetDataFromObject
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::GetDataFromObject(const AEDesc *token, AEDesc *desiredTypes, AEDesc *data)
|
|
{
|
|
OSErr err = noErr;
|
|
|
|
ConstAETokenDesc tokenDesc(token);
|
|
DescType aType = mClass;
|
|
Rect aRect;
|
|
|
|
Point aPoint;
|
|
Boolean aBoolean;
|
|
long index;
|
|
CStr255 windowTitle;
|
|
char* urlString = NULL;
|
|
|
|
DescType propertyCode = tokenDesc.GetPropertyCode();
|
|
WindowPtr window = tokenDesc.GetWindowPtr();
|
|
|
|
switch (propertyCode)
|
|
{
|
|
case pProperties:
|
|
err = AECreateList(NULL, 0L, true, data);
|
|
ThrowIfOSErr(err);
|
|
|
|
err = AEPutKeyPtr(data, pObjectType, typeType, &aType, sizeof(DescType));
|
|
|
|
GetCleanedWindowName(window, windowTitle, 255);
|
|
err = AEPutKeyPtr(data, pTitle, typeChar, windowTitle, strlen(windowTitle));
|
|
|
|
GetWindowUrlString(window, &urlString);
|
|
if (urlString)
|
|
{
|
|
err = AEPutKeyPtr(data, AE_www_typeWindowURL, typeChar, urlString, strlen(urlString));
|
|
nsMemory::Free(urlString); urlString = NULL;
|
|
}
|
|
|
|
index = GetWindowIndex(GetThisWindowKind(), window);
|
|
err = AEPutKeyPtr(data, pIndex, typeLongInteger, &index, sizeof(long));
|
|
|
|
GetWindowGlobalBounds(window, &aRect);
|
|
err = AEPutKeyPtr(data, pBounds, typeQDRectangle, &aRect, sizeof(Rect));
|
|
aPoint.h = aRect.left;
|
|
aPoint.v = aRect.top;
|
|
err = AEPutKeyPtr(data, pLocation, typeQDPoint, &aPoint, sizeof(Point));
|
|
|
|
aBoolean = WindowIsCloseable(window);
|
|
err = AEPutKeyPtr(data, pHasCloseBox, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = WindowHasTitleBar(window);
|
|
err = AEPutKeyPtr(data, pHasTitleBar, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = WindowIsModal(window);
|
|
err = AEPutKeyPtr(data, pIsModal, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = WindowIsResizeable(window);
|
|
err = AEPutKeyPtr(data, pIsResizable, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = WindowIsZoomable(window);
|
|
err = AEPutKeyPtr(data, pIsZoomable, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = WindowIsZoomed(window);
|
|
err = AEPutKeyPtr(data, pIsZoomed, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = !WindowIsModal(window);
|
|
err = AEPutKeyPtr(data, pIsModeless, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = WindowIsModal(window) && WindowHasTitleBar(window);
|
|
err = AEPutKeyPtr(data, pIsMovableModal, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = WindowIsFloating(window);
|
|
err = AEPutKeyPtr(data, pIsFloating, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
|
|
aBoolean = IsWindowVisible(window);
|
|
err = AEPutKeyPtr(data, pVisible, typeBoolean, &aBoolean, sizeof(Boolean));
|
|
break;
|
|
|
|
case pBestType:
|
|
case pClass:
|
|
case pDefaultType:
|
|
case pObjectType:
|
|
err = AECreateDesc(typeType, &aType, sizeof(DescType), data);
|
|
break;
|
|
|
|
case pBounds:
|
|
GetWindowGlobalBounds(window, &aRect);
|
|
err = AECreateDesc(typeQDRectangle, &aRect, sizeof(Rect), data);
|
|
break;
|
|
|
|
case pLocation:
|
|
GetWindowGlobalBounds(window, &aRect);
|
|
aPoint.h = aRect.left;
|
|
aPoint.v = aRect.top;
|
|
err = AECreateDesc(typeQDPoint, &aPoint, sizeof(Point), data);
|
|
break;
|
|
|
|
case pIsModeless:
|
|
aBoolean = !WindowIsModal(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pIsMovableModal:
|
|
aBoolean = WindowIsModal(window) && WindowHasTitleBar(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pHasCloseBox:
|
|
aBoolean = WindowIsCloseable(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pHasTitleBar:
|
|
aBoolean = WindowHasTitleBar(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pIndex:
|
|
index = GetWindowIndex(GetThisWindowKind(), window);
|
|
err = AECreateDesc(typeLongInteger, &index, sizeof(long), data);
|
|
break;
|
|
|
|
case pIsModal:
|
|
aBoolean = WindowIsModal(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pIsResizable:
|
|
aBoolean = WindowIsResizeable(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pIsZoomable:
|
|
aBoolean = WindowIsZoomable(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pIsZoomed:
|
|
aBoolean = WindowIsZoomed(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pVisible:
|
|
aBoolean = IsWindowVisible(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pIsFloating:
|
|
aBoolean = WindowIsFloating(window);
|
|
err = AECreateDesc(typeBoolean, &aBoolean, sizeof(Boolean), data);
|
|
break;
|
|
|
|
case pName: // Synonym for pTitle
|
|
case pTitle:
|
|
GetCleanedWindowName(window, windowTitle, 255);
|
|
err = AECreateDesc(typeChar, windowTitle, strlen(windowTitle), data);
|
|
break;
|
|
|
|
case AE_www_typeWindowURL:
|
|
GetWindowUrlString(window, &urlString);
|
|
if (urlString)
|
|
{
|
|
err = AECreateDesc(typeChar, urlString, strlen(urlString), data);
|
|
nsMemory::Free(urlString); urlString = NULL;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Inherited::GetDataFromObject(token, desiredTypes, data);
|
|
break;
|
|
}
|
|
|
|
ThrowIfOSErr(err);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
SetDataForObject
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::SetDataForObject(const AEDesc *token, AEDesc *data)
|
|
{
|
|
OSErr err;
|
|
|
|
ConstAETokenDesc tokenDesc(token);
|
|
|
|
Boolean usePropertyCode = tokenDesc.UsePropertyCode();
|
|
WindowPtr window = tokenDesc.GetWindowPtr();
|
|
|
|
if (usePropertyCode == false)
|
|
{
|
|
ThrowIfOSErr(errAEWriteDenied);
|
|
}
|
|
else
|
|
{
|
|
DescType propertyCode = tokenDesc.GetPropertyCode();
|
|
|
|
// Convert the single property to a record containing one property
|
|
|
|
if (data->descriptorType == typeAERecord)
|
|
{
|
|
SetWindowProperties(window, data);
|
|
}
|
|
else // Build a record with one property
|
|
{
|
|
StAEDesc propertyRecord;
|
|
|
|
err = AECreateList(nil, 0, true, &propertyRecord);
|
|
ThrowIfOSErr(err);
|
|
|
|
err = AEPutKeyDesc(&propertyRecord, propertyCode, data);
|
|
ThrowIfOSErr(err);
|
|
|
|
SetWindowProperties(window, &propertyRecord);
|
|
}
|
|
}
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CanSetProperty
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
Boolean AEWindowClass::CanSetProperty(DescType propertyCode)
|
|
{
|
|
Boolean result = false;
|
|
|
|
switch (propertyCode)
|
|
{
|
|
// Properties we can set:
|
|
|
|
case pProperties:
|
|
result = true;
|
|
break;
|
|
|
|
// Properties that can be set only for certain types of windows:
|
|
|
|
case pTitle:
|
|
case pName: // Synonym for pTitle
|
|
|
|
case pBounds:
|
|
case pLocation:
|
|
case pIndex:
|
|
case pVisible:
|
|
case pIsZoomed:
|
|
result = true;
|
|
break;
|
|
|
|
// Properties we should be able to set, but not implemented yet:
|
|
case AE_www_typeWindowURL:
|
|
result = false;
|
|
break;
|
|
|
|
// Properties we can't set:
|
|
|
|
default:
|
|
case pBestType:
|
|
case pClass:
|
|
case pDefaultType:
|
|
case pObjectType:
|
|
|
|
case pIsModeless:
|
|
case pIsMovableModal:
|
|
case pIsSuspended:
|
|
case pIsPalette:
|
|
case pIsDialog:
|
|
|
|
case pHasCloseBox:
|
|
case pHasTitleBar:
|
|
|
|
case pIsFloating:
|
|
case pIsModal:
|
|
case pIsResizable:
|
|
case pIsZoomable:
|
|
result = Inherited::CanSetProperty(propertyCode);
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CanGetProperty
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
Boolean AEWindowClass::CanGetProperty(DescType propertyCode)
|
|
{
|
|
Boolean result = false;
|
|
|
|
switch (propertyCode)
|
|
{
|
|
// Properties we can get:
|
|
|
|
case pBestType:
|
|
case pClass:
|
|
case pDefaultType:
|
|
case pObjectType:
|
|
|
|
case pContents:
|
|
|
|
case pProperties:
|
|
case keyAEProperties:
|
|
|
|
case pTitle:
|
|
case pName: // Synonym for pTitle
|
|
|
|
case AE_www_typeWindowURL:
|
|
|
|
case pIsModeless:
|
|
case pIsMovableModal:
|
|
case pIsSuspended:
|
|
case pIsPalette:
|
|
case pIsDialog:
|
|
|
|
case pBounds:
|
|
case pLocation:
|
|
|
|
case pHasCloseBox:
|
|
case pHasTitleBar:
|
|
case pIndex:
|
|
|
|
case pIsFloating:
|
|
case pIsModal:
|
|
case pIsResizable:
|
|
case pIsZoomable:
|
|
|
|
case pIsZoomed:
|
|
case pVisible:
|
|
result = true;
|
|
break;
|
|
|
|
// Properties we can't get:
|
|
default:
|
|
result = Inherited::CanGetProperty(propertyCode);
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
SetWindowProperties
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::SetWindowProperties(WindowPtr window, const AEDesc *propertyRecord)
|
|
{
|
|
OSErr err = noErr;
|
|
OSErr ignoreError = noErr;
|
|
long numProperties = 0L;
|
|
StAEDesc data;
|
|
|
|
if (propertyRecord == nil || propertyRecord->descriptorType != typeAERecord)
|
|
{
|
|
ThrowIfOSErr(errAEWrongDataType);
|
|
}
|
|
|
|
err = AECountItems(propertyRecord, &numProperties);
|
|
ThrowIfOSErr(err);
|
|
if (numProperties <= 0)
|
|
ThrowIfOSErr(paramErr);
|
|
|
|
StPortSetter portSetter(window);
|
|
|
|
// pBounds
|
|
|
|
ignoreError = AEGetKeyDesc(propertyRecord, pBounds, typeQDRectangle, &data);
|
|
if (ignoreError != errAEDescNotFound)
|
|
{
|
|
Rect r;
|
|
err = DescToRect(&data, &r);
|
|
|
|
if (err == noErr)
|
|
{
|
|
MoveWindow(window, r.left, r.top, false);
|
|
// short windowWidth = r.right - r.left;
|
|
// short windowDepth = r.bottom - r.top;
|
|
// DoResize(window, windowWidth, windowDepth);
|
|
}
|
|
|
|
data.Clear();
|
|
}
|
|
|
|
// pLocation
|
|
|
|
ignoreError = AEGetKeyDesc(propertyRecord, pLocation, typeQDPoint, &data);
|
|
if (ignoreError != errAEDescNotFound)
|
|
{
|
|
Point p;
|
|
err = DescToPoint(&data, &p);
|
|
|
|
if (err == noErr)
|
|
MoveWindow(window, p.h, p.v, false); // don't let Window Manager bring it to front!
|
|
|
|
data.Clear();
|
|
}
|
|
|
|
// pIndex
|
|
|
|
ignoreError = AEGetKeyDesc(propertyRecord, pIndex, typeLongInteger, &data);
|
|
if (ignoreError != errAEDescNotFound)
|
|
{
|
|
long index;
|
|
long numWindows;
|
|
WindowPtr behindWindow;
|
|
|
|
err = DescToLong(&data, &index);
|
|
|
|
if (err == noErr)
|
|
{
|
|
numWindows = CountWindows(GetThisWindowKind());
|
|
if (index < 0)
|
|
index = numWindows + index + 1;
|
|
|
|
if (index == 1)
|
|
{
|
|
SelectWindow(window);
|
|
}
|
|
else
|
|
{
|
|
behindWindow = GetWindowByIndex(GetThisWindowKind(), index);
|
|
if (behindWindow != NULL)
|
|
{
|
|
SendBehind(window, behindWindow);
|
|
}
|
|
else
|
|
{
|
|
err = errAEEventNotHandled;
|
|
}
|
|
}
|
|
}
|
|
|
|
data.Clear();
|
|
}
|
|
|
|
// pIsZoomed
|
|
|
|
ignoreError = AEGetKeyDesc(propertyRecord, pIsZoomed, typeBoolean, &data);
|
|
if (ignoreError != errAEDescNotFound)
|
|
{
|
|
Boolean zoomIt;
|
|
|
|
err = DescToBoolean(&data, &zoomIt);
|
|
|
|
if (err == noErr)
|
|
{
|
|
if (zoomIt)
|
|
ZoomWindow(window, inZoomOut, false);
|
|
else
|
|
ZoomWindow(window, inZoomIn, false);
|
|
}
|
|
|
|
data.Clear();
|
|
}
|
|
|
|
// pVisible
|
|
|
|
ignoreError = AEGetKeyDesc(propertyRecord, pVisible, typeBoolean, &data);
|
|
if (ignoreError != errAEDescNotFound)
|
|
{
|
|
Boolean showIt;
|
|
err = DescToBoolean(&data, &showIt);
|
|
|
|
if (err == noErr)
|
|
{
|
|
if (showIt)
|
|
ShowWindow(window);
|
|
else
|
|
HideWindow(window);
|
|
}
|
|
|
|
data.Clear();
|
|
}
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
MakeWindowObjectSpecifier
|
|
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::MakeWindowObjectSpecifier(WindowPtr wind, AEDesc *outSpecifier)
|
|
{
|
|
// fill in the reply with the newly created object
|
|
CoreTokenRecord coreToken;
|
|
StAEDesc windowToken;
|
|
|
|
coreToken.window = wind;
|
|
|
|
OSErr err = ::AECreateDesc(typeObjectSpecifier, &coreToken, sizeof(CoreTokenRecord), &windowToken);
|
|
ThrowIfOSErr(err);
|
|
|
|
CreateSelfSpecifier(&windowToken, outSpecifier);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CreateSelfSpecifier
|
|
|
|
----------------------------------------------------------------------------*/
|
|
void AEWindowClass::CreateSelfSpecifier(const AEDesc *token, AEDesc *outSpecifier)
|
|
{
|
|
ConstAETokenDesc tokenDesc(token);
|
|
WindowPtr window = tokenDesc.GetWindowPtr();
|
|
long position = GetWindowIndex(mWindowKind, window);
|
|
AEDesc selfDesc = { typeNull, nil };
|
|
AEDesc containerSpecifier = { typeNull, nil };
|
|
DescType desiredClass = mClass;
|
|
DescType keyForm = formAbsolutePosition;
|
|
OSErr err = noErr;
|
|
|
|
GetContainerSpecifier(token, &containerSpecifier);
|
|
|
|
err = ::AECreateDesc(typeLongInteger, &position, sizeof(long), &selfDesc);
|
|
ThrowIfOSErr(err);
|
|
|
|
err = ::CreateObjSpecifier(desiredClass, &containerSpecifier, keyForm, &selfDesc, true, outSpecifier);
|
|
ThrowIfOSErr(err);
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
/*----------------------------------------------------------------------------
|
|
CountWindows
|
|
|
|
----------------------------------------------------------------------------*/
|
|
long AEWindowClass::CountWindows(TWindowKind windowKind)
|
|
{
|
|
return CountWindowsOfKind(windowKind);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetWindowByIndex
|
|
|
|
----------------------------------------------------------------------------*/
|
|
WindowPtr AEWindowClass::GetWindowByIndex(TWindowKind windowKind, long index)
|
|
{
|
|
return GetIndexedWindowOfKind(windowKind, index);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetWindowByTitle
|
|
|
|
----------------------------------------------------------------------------*/
|
|
WindowPtr AEWindowClass::GetWindowByTitle(TWindowKind windowKind, ConstStr63Param title)
|
|
{
|
|
CStr255 windowName;
|
|
CopyPascalToCString((const StringPtr)title, windowName, 255);
|
|
return GetNamedOrFrontmostWindow(windowKind, windowName);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetWindowIndex
|
|
|
|
----------------------------------------------------------------------------*/
|
|
long AEWindowClass::GetWindowIndex(TWindowKind windowKind, WindowPtr window)
|
|
{
|
|
return nsWindowUtils::GetWindowIndex(windowKind, window);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------
|
|
GetPreviousWindow
|
|
|
|
----------------------------------------------------------------------------*/
|
|
WindowPtr AEWindowClass::GetPreviousWindow(TWindowKind windowKind, WindowPtr wind)
|
|
{
|
|
short windowIndex = GetWindowIndex(windowKind, wind);
|
|
return GetIndexedWindowOfKind(windowKind, windowIndex - 1);
|
|
}
|
|
|
|
|