Back to index

lightning-sunbird  0.9+nobinonly
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Friends
AEWindowClass Class Reference

#include <nsAEWindowClass.h>

Inheritance diagram for AEWindowClass:
Inheritance graph
[legend]
Collaboration diagram for AEWindowClass:
Collaboration graph
[legend]

List of all members.

Public Member Functions

void DispatchEvent (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)

Static Public Member Functions

static pascal OSErr DocumentAccessor (DescType desiredClass, const AEDesc *containerToken, DescType containerClass, DescType keyForm, const AEDesc *keyData, AEDesc *resultToken, long refCon)
static long CountWindows (TWindowKind windowKind)
static pascal OSErr ItemFromContainerAccessor (DescType desiredClass, const AEDesc *containerToken, DescType containerClass, DescType keyForm, const AEDesc *keyData, AEDesc *resultToken, long refCon)

Protected Types

enum  { kAEExtract = 'Extr', kExtractKeyDestFolder = 'Fold', kAESendMessage = 'Post' }

Protected Member Functions

 AEWindowClass (DescType classType, TWindowKind windowKind)
 ~AEWindowClass ()
void GetDocumentFromWindow (DescType desiredClass, const AEDesc *containerToken, DescType containerClass, DescType keyForm, const AEDesc *keyData, AEDesc *resultToken)
virtual void GetItemFromContainer (DescType desiredClass, const AEDesc *containerToken, DescType containerClass, DescType keyForm, const AEDesc *keyData, AEDesc *resultToken)
virtual void CompareObjects (DescType comparisonOperator, const AEDesc *object, const AEDesc *descriptorOrObject, Boolean *result)
virtual void CountObjects (DescType desiredType, DescType containerClass, const AEDesc *container, long *result)
virtual void HandleClose (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleDataSize (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleDelete (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleDuplicate (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleExists (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleMake (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleMove (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleOpen (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandlePrint (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleQuit (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleSave (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void CreateSelfSpecifier (const AEDesc *token, AEDesc *outSpecifier)
virtual void GetDataFromObject (const AEDesc *token, AEDesc *desiredTypes, AEDesc *data)
virtual void SetDataForObject (const AEDesc *token, AEDesc *data)
virtual Boolean CanSetProperty (DescType propertyCode)
virtual Boolean CanGetProperty (DescType propertyCode)
void SetWindowProperties (WindowPtr wind, const AEDesc *propertyRecord)
void MakeWindowObjectSpecifier (WindowPtr wind, AEDesc *outSpecifier)
WindowPtr GetWindowByIndex (TWindowKind windowKind, long index)
WindowPtr GetWindowByTitle (TWindowKind windowKind, ConstStr63Param title)
long GetWindowIndex (TWindowKind windowKind, WindowPtr window)
WindowPtr GetPreviousWindow (TWindowKind windowKind, WindowPtr wind)
TWindowKind GetThisWindowKind ()
virtual void GetPropertyFromObject (DescType desiredClass, const AEDesc *containerToken, DescType containerClass, DescType keyForm, const AEDesc *keyData, AEDesc *resultToken)
virtual void GetProperty (DescType desiredClass, const AEDesc *containerToken, DescType containerClass, DescType keyForm, const AEDesc *keyData, AEDesc *resultToken)
virtual void HandleCount (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleSetData (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleGetData (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleReOpen (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleRun (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleExtract (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
virtual void HandleSendMessage (AEDesc *token, const AppleEvent *appleEvent, AppleEvent *reply)
void CreateSpecifier (const AEDesc *token, AEDesc *outSpecifier)
virtual void GetContainerSpecifier (const AEDesc *token, AEDesc *outContainerSpecifier)
void GetDataFromListOrObject (const AEDesc *tokenOrTokenList, AEDesc *desiredTypes, AEDesc *data)
void SetDataForListOrObject (const AEDesc *tokenOrTokenList, const AppleEvent *appleEvent, AppleEvent *reply)
void GetDataFromList (const AEDesc *srcList, AEDesc *desiredTypes, AEDesc *dstList)
void SetDataForList (const AEDesc *token, AEDesc *data)
void GetPropertyFromListOrObject (DescType desiredClass, const AEDesc *containerToken, DescType containerClass, DescType keyForm, const AEDesc *keyData, AEDesc *resultToken)
void GetPropertyFromList (DescType desiredClass, const AEDesc *containerToken, DescType containerClass, DescType keyForm, const AEDesc *keyData, AEDesc *resultToken)
virtual DescType GetKeyEventDataAs (DescType propertyCode)
DescType GetClass ()
virtual void MakeNewObject (const DescType insertionPosition, const AEDesc *token, const AEDesc *ptrToWithData, const AEDesc *ptrToWithProperties, AppleEvent *reply)

Protected Attributes

TWindowKind mWindowKind
OSLAccessorUPP mDocumentAccessor
DescType mClass
DescType mContainerClass
OSLAccessorUPP mItemFromContainerAccessor

Private Types

typedef AEGenericClass Inherited

Friends

class AECoreClass

Detailed Description

Definition at line 85 of file nsAEWindowClass.h.


Member Typedef Documentation

Definition at line 90 of file nsAEWindowClass.h.


Member Enumeration Documentation

anonymous enum [protected, inherited]
Enumerator:
kAEExtract 
kExtractKeyDestFolder 
kAESendMessage 

Definition at line 78 of file nsAEGenericClass.h.

            {
              kAEExtract                  = 'Extr',
              kExtractKeyDestFolder       = 'Fold',
              
              kAESendMessage              = 'Post'
       };

Constructor & Destructor Documentation

AEWindowClass::AEWindowClass ( DescType  classType,
TWindowKind  windowKind 
) [protected]

Definition at line 174 of file nsAEWindowClass.cpp.

:      AEGenericClass(classType, typeNull)
,      mWindowKind(windowKind)
,      mDocumentAccessor(nil)
{
}

Definition at line 185 of file nsAEWindowClass.cpp.

{
       if (mDocumentAccessor)
              DisposeOSLAccessorUPP(mDocumentAccessor);
}

Member Function Documentation

Boolean AEWindowClass::CanGetProperty ( DescType  propertyCode) [protected, virtual]

Implements AEGenericClass.

Definition at line 697 of file nsAEWindowClass.cpp.

{
       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;
}

Here is the call graph for this function:

Boolean AEWindowClass::CanSetProperty ( DescType  propertyCode) [protected, virtual]

Implements AEGenericClass.

Definition at line 633 of file nsAEWindowClass.cpp.

{
       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;
}

Here is the call graph for this function:

void AEWindowClass::CompareObjects ( DescType  comparisonOperator,
const AEDesc *  object,
const AEDesc *  descriptorOrObject,
Boolean result 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 213 of file nsAEWindowClass.cpp.

{
       

}
void AEWindowClass::CountObjects ( DescType  desiredType,
DescType  containerClass,
const AEDesc *  container,
long result 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 227 of file nsAEWindowClass.cpp.

Here is the call graph for this function:

long AEWindowClass::CountWindows ( TWindowKind  windowKind) [static]

Definition at line 942 of file nsAEWindowClass.cpp.

{
       return CountWindowsOfKind(windowKind);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEWindowClass::CreateSelfSpecifier ( const AEDesc *  token,
AEDesc *  outSpecifier 
) [protected, virtual]

Implements AEGenericClass.

Definition at line 916 of file nsAEWindowClass.cpp.

{
       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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::CreateSpecifier ( const AEDesc *  token,
AEDesc *  outSpecifier 
) [protected, inherited]

Definition at line 840 of file nsAEGenericClass.cpp.

{
       CreateSelfSpecifier(token, outSpecifier);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::DispatchEvent ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [inherited]

Definition at line 97 of file nsAEGenericClass.cpp.

{
       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;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static pascal OSErr AEWindowClass::DocumentAccessor ( DescType  desiredClass,
const AEDesc *  containerToken,
DescType  containerClass,
DescType  keyForm,
const AEDesc *  keyData,
AEDesc *  resultToken,
long  refCon 
) [static]
DescType AEGenericClass::GetClass ( ) [inline, protected, inherited]

Definition at line 193 of file nsAEGenericClass.h.

{ return mClass; }

Here is the caller graph for this function:

void AEGenericClass::GetContainerSpecifier ( const AEDesc *  token,
AEDesc *  outContainerSpecifier 
) [protected, virtual, inherited]

Definition at line 849 of file nsAEGenericClass.cpp.

{
       outContainerSpecifier->descriptorType = typeNull;
       outContainerSpecifier->dataHandle = nil;
       
       AEDispatchHandler*   handler = AECoreClass::GetDispatchHandlerForClass(mContainerClass);
       if (handler)
       {
              handler->CreateSelfSpecifier(token, outContainerSpecifier);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::GetDataFromList ( const AEDesc *  srcList,
AEDesc *  desiredTypes,
AEDesc *  dstList 
) [protected, inherited]

Definition at line 692 of file nsAEGenericClass.cpp.

{
       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);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::GetDataFromListOrObject ( const AEDesc *  tokenOrTokenList,
AEDesc *  desiredTypes,
AEDesc *  data 
) [protected, inherited]

Definition at line 632 of file nsAEGenericClass.cpp.

{
       if (AEListUtils::TokenContainsTokenList(tokenOrTokenList) == false)
       {
              GetDataFromObject(tokenOrTokenList, desiredTypes, data);
       }
       else
       {
              ThrowIfOSErr(AECreateList(nil, 0, false, data));
              GetDataFromList(tokenOrTokenList, desiredTypes, data);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEWindowClass::GetDataFromObject ( const AEDesc *  token,
AEDesc *  desiredTypes,
AEDesc *  data 
) [protected, virtual]

Implements AEGenericClass.

Definition at line 411 of file nsAEWindowClass.cpp.

{
       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);
}

Here is the call graph for this function:

void AEWindowClass::GetDocumentFromWindow ( DescType  desiredClass,
const AEDesc *  containerToken,
DescType  containerClass,
DescType  keyForm,
const AEDesc *  keyData,
AEDesc *  resultToken 
) [protected]
void AEWindowClass::GetItemFromContainer ( DescType  desiredClass,
const AEDesc *  containerToken,
DescType  containerClass,
DescType  keyForm,
const AEDesc *  keyData,
AEDesc *  resultToken 
) [protected, virtual]

Implements AEGenericClass.

Definition at line 198 of file nsAEWindowClass.cpp.

{
       AEWindowIterator            windowIterator(GetClass(), GetThisWindowKind());
       windowIterator.GetItemFromContainer(desiredClass, containerToken, containerClass, keyForm, keyData, resultToken);
}

Here is the call graph for this function:

DescType AEGenericClass::GetKeyEventDataAs ( DescType  propertyCode) [protected, virtual, inherited]

Reimplemented in AEApplicationClass.

Definition at line 799 of file nsAEGenericClass.cpp.

{
       return typeWildCard;
}

Here is the caller graph for this function:

WindowPtr AEWindowClass::GetPreviousWindow ( TWindowKind  windowKind,
WindowPtr  wind 
) [protected]

Definition at line 982 of file nsAEWindowClass.cpp.

{
       short  windowIndex = GetWindowIndex(windowKind, wind);
       return GetIndexedWindowOfKind(windowKind, windowIndex - 1);
}

Here is the call graph for this function:

void AEGenericClass::GetProperty ( DescType  desiredClass,
const AEDesc *  containerToken,
DescType  containerClass,
DescType  keyForm,
const AEDesc *  keyData,
AEDesc *  resultToken 
) [protected, virtual, inherited]

Reimplemented in AEApplicationClass.

Definition at line 213 of file nsAEGenericClass.cpp.

{
       
       // call the base class utility method, which calls back up to the object
       GetPropertyFromListOrObject(desiredClass, containerToken, containerClass, keyForm, keyData, resultToken);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::GetPropertyFromList ( DescType  desiredClass,
const AEDesc *  containerToken,
DescType  containerClass,
DescType  keyForm,
const AEDesc *  keyData,
AEDesc *  resultToken 
) [protected, inherited]

Definition at line 892 of file nsAEGenericClass.cpp.

{
       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);
       }
       
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::GetPropertyFromListOrObject ( DescType  desiredClass,
const AEDesc *  containerToken,
DescType  containerClass,
DescType  keyForm,
const AEDesc *  keyData,
AEDesc *  resultToken 
) [protected, inherited]

Definition at line 867 of file nsAEGenericClass.cpp.

{
       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);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::GetPropertyFromObject ( DescType  desiredClass,
const AEDesc *  containerToken,
DescType  containerClass,
DescType  keyForm,
const AEDesc *  keyData,
AEDesc *  resultToken 
) [protected, virtual, inherited]

Definition at line 938 of file nsAEGenericClass.cpp.

{
       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);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 175 of file nsAEWindowClass.h.

{ return mWindowKind; }

Here is the caller graph for this function:

WindowPtr AEWindowClass::GetWindowByIndex ( TWindowKind  windowKind,
long  index 
) [protected]

Definition at line 952 of file nsAEWindowClass.cpp.

{
       return GetIndexedWindowOfKind(windowKind, index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

WindowPtr AEWindowClass::GetWindowByTitle ( TWindowKind  windowKind,
ConstStr63Param  title 
) [protected]

Definition at line 961 of file nsAEWindowClass.cpp.

{
       CStr255              windowName;
       CopyPascalToCString((const StringPtr)title, windowName, 255);
       return GetNamedOrFrontmostWindow(windowKind, windowName);
}

Here is the call graph for this function:

long AEWindowClass::GetWindowIndex ( TWindowKind  windowKind,
WindowPtr  window 
) [protected]

Definition at line 972 of file nsAEWindowClass.cpp.

{
       return nsWindowUtils::GetWindowIndex(windowKind, window);
}

Here is the caller graph for this function:

void AEWindowClass::HandleClose ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 241 of file nsAEWindowClass.cpp.

{
       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);
       }
}

Here is the call graph for this function:

void AEGenericClass::HandleCount ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual, inherited]

Reimplemented in AEApplicationClass.

Definition at line 278 of file nsAEGenericClass.cpp.

{
       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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEWindowClass::HandleDataSize ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 307 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEWindowClass::HandleDelete ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 319 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEWindowClass::HandleDuplicate ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 328 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEWindowClass::HandleExists ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 337 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEGenericClass::HandleExtract ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual, inherited]

Definition at line 581 of file nsAEGenericClass.cpp.

{
       ThrowOSErr(errAEEventNotHandled);
}

Here is the caller graph for this function:

void AEGenericClass::HandleGetData ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual, inherited]

Definition at line 318 of file nsAEGenericClass.cpp.

{
       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);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEWindowClass::HandleMake ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 348 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEWindowClass::HandleMove ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 358 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEWindowClass::HandleOpen ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 368 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEWindowClass::HandlePrint ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 378 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEWindowClass::HandleQuit ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 388 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEGenericClass::HandleReOpen ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual, inherited]

Reimplemented in AEApplicationClass.

Definition at line 530 of file nsAEGenericClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}

Here is the caller graph for this function:

void AEGenericClass::HandleRun ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual, inherited]

Reimplemented in AEApplicationClass.

Definition at line 540 of file nsAEGenericClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}

Here is the caller graph for this function:

void AEWindowClass::HandleSave ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual]

Reimplemented from AEGenericClass.

Definition at line 398 of file nsAEWindowClass.cpp.

{
       ThrowIfOSErr(errAEEventNotHandled);
}
void AEGenericClass::HandleSendMessage ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual, inherited]

Definition at line 592 of file nsAEGenericClass.cpp.

{
       ThrowOSErr(errAEEventNotHandled);
}

Here is the caller graph for this function:

void AEGenericClass::HandleSetData ( AEDesc *  token,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, virtual, inherited]

Definition at line 340 of file nsAEGenericClass.cpp.

{
       SetDataForListOrObject(token, appleEvent, reply);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pascal OSErr AEGenericClass::ItemFromContainerAccessor ( DescType  desiredClass,
const AEDesc *  containerToken,
DescType  containerClass,
DescType  keyForm,
const AEDesc *  keyData,
AEDesc *  resultToken,
long  refCon 
) [static, inherited]

Definition at line 232 of file nsAEGenericClass.cpp.

{
       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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::MakeNewObject ( const DescType  insertionPosition,
const AEDesc *  token,
const AEDesc *  ptrToWithData,
const AEDesc *  ptrToWithProperties,
AppleEvent *  reply 
) [protected, virtual, inherited]

Definition at line 976 of file nsAEGenericClass.cpp.

{
       ThrowOSErr(errAEEventNotHandled);
}

Here is the caller graph for this function:

void AEWindowClass::MakeWindowObjectSpecifier ( WindowPtr  wind,
AEDesc *  outSpecifier 
) [protected]

Definition at line 897 of file nsAEWindowClass.cpp.

{
       // 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);
}

Here is the call graph for this function:

void AEGenericClass::SetDataForList ( const AEDesc *  token,
AEDesc *  data 
) [protected, inherited]

Reimplemented in AEDocumentClass.

Definition at line 759 of file nsAEGenericClass.cpp.

{
       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
                     }
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEGenericClass::SetDataForListOrObject ( const AEDesc *  tokenOrTokenList,
const AppleEvent *  appleEvent,
AppleEvent *  reply 
) [protected, inherited]

Definition at line 651 of file nsAEGenericClass.cpp.

{
       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);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void AEWindowClass::SetDataForObject ( const AEDesc *  token,
AEDesc *  data 
) [protected, virtual]

Implements AEGenericClass.

Definition at line 588 of file nsAEWindowClass.cpp.

{
       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);
              }
       }
}

Here is the call graph for this function:

void AEWindowClass::SetWindowProperties ( WindowPtr  wind,
const AEDesc *  propertyRecord 
) [protected]

Definition at line 759 of file nsAEWindowClass.cpp.

{
       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();
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Friends And Related Function Documentation

friend class AECoreClass [friend]

Definition at line 87 of file nsAEWindowClass.h.


Member Data Documentation

DescType AEGenericClass::mClass [protected, inherited]

Definition at line 209 of file nsAEGenericClass.h.

DescType AEGenericClass::mContainerClass [protected, inherited]

Definition at line 210 of file nsAEGenericClass.h.

OSLAccessorUPP AEWindowClass::mDocumentAccessor [protected]

Definition at line 187 of file nsAEWindowClass.h.

OSLAccessorUPP AEGenericClass::mItemFromContainerAccessor [protected, inherited]

Definition at line 212 of file nsAEGenericClass.h.

Definition at line 183 of file nsAEWindowClass.h.


The documentation for this class was generated from the following files: