wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
b967b5aec8
gecko/xpfe/bootstrap/appleevents/nsAEWindowClass.cpp

987 lines
27 KiB
C++
Raw Blame History

/* -*- 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"
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);
}
Reference in New Issue View Git Blame Copy Permalink