MacFormat 1995 January/macformat-020.iso/Shareware City/Developers/apps.to.go/DTS.Lib/DTS.Lib.headers/AppWannabe.h

C/C++ Source or Header | 1994-06-11 | 25.7 KB | 643 lines | [TEXT/MPS ]

#ifndef __APPWANNABE__
#define __APPWANNABE__

#ifndef __TYPES__
#include <Types.h>
#endif




/********** DoEvent.c **********/


void            DoEvent(EventRecord *event);
    /*
    **    ¶ •AppWannabe (DoEvent.c).  This is where event dispatching occurs.
    **
    **    INPUT:    event
    **
    **    This AppWannabe is where dispatching for the event occurs. */

void            DoActivate(WindowPtr window);
    /*
    **    ¶ •AppWannabe (DoEvent.c).  Called by framework to activate or deactivate a window.
    **
    **    INPUT:    window        This is the window being activated or deactivated.
    **
    **    The application framework calls this AppWannabe function when a window needs
    **    activation or deactivation.  Note that this may happen at times other than
    **    event handling.  For example:  If you call HiliteWindows, if some windows are
    **    found with the wrong hilite value, they will be hilited or unhilited, and
    **    DoActivate will be called to give the application a chance to do whatever
    **    else is appropriate for activation or deactivation of the window. */

void            DoCursor(void);
    /*
    **    ¶ •AppWannabe (DoEvent.c).  Called by framework to adjust the cursor.
    **
    **    The application framework calls this AppWannabe function when the cursor
    **    needs updating.  The application does whatever is appropriate, which in many cases
    **    is simply to call the framework function DoWindowCursor.  See DoWindowCursor
    **    for more information. */



/********** File.c **********/

OSErr            InitDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (File.c).  Called by framework to instantiate doc handle (frHndl).
    **
    **    INPUT:    frHndl        The file (document) reference handle.
    **    RESULT:    OSErr
    **
    **    The application framework calls this AppWannabe function when a file reference
    **    handle needs to be further initialized.  The frHndl has already been initialized
    **    with default values.  This is the application’s chance to change these values
    **    before the window is created for the document (if one is to be created), and also
    **    if this was called by OpenDocument, then the document will also be read.  This is
    **    the application’s chance to change the file read/write procs so that if there is a
    **    custom file format, the correct read/write routines will be called for this
    **    document. */

long            InitDocumentSize(OSType sftype);
    /*
    **    ¶ •AppWannabe (File.c).  Called by framework to get size of doc handle to create.
    **
    **    INPUT:    sftype        The OSType of the document about to be created.
    **    RESULT:    long        The size that the file reference handle should be created.
    **
    **    The application framework calls this AppWannabe function when it is about to
    **    create a file reference handle.  The framework needs to know how big to create the
    **    handle.  Your application may wish to store additional fields in the frHndl, and so
    **    therefore it may be a different size than usual.  See the various sample
    **    applications for a sample of this function (in the source file File.c).  Note that
    **    for the ViewHierarchy debugging window, a different size is returned. */



/********** Menu.c **********/

void            DoAdjustMenus(void);
    /*
    **    ¶ •AppWannabe (Menu.c).  Called by framework to activate or deactivate a window.
    **
    **    The application framework calls this AppWannabe function when menus need
    **    adjusting.  The application can then “adjust” the menu items any way it sees fit.
    **
    **    There is a framework service for adjusting the menus called DoAdjustMBARMenus.
    **    The MBAR in the name indicates that it restricts its actions to the menus in
    **    the designated MBAR resource.  Menus other than those mentioned in the MBAR
    **    resource are not handled by the framework.
    **
    **    DoAdjustMBARMenus walks the MBAR, and calls the application for each menu it
    **    finds.  All items in the menu are first disabled, and then the application is
    **    called.  This allows the application to only worry about enabling items, which
    **    should simplify the task.
    **
    **    __________
    **
    **    Also see:    AdjustMenuItems. */

Boolean            DoMenuCommand(short menuID, short menuItem);
    /*
    **    ¶ •AppWannabe (Menu.c).  Called by framework to execute menu command.
    **
    **    INPUT:    menuID
    **            menuItem
    **
    **    The application framework calls this AppWannabe function when a menu
    **    command has been received and it needs to be handled.  Note that the menuItem
    **    has already been converted to a "soft" menuItem if you have a STR# hard <-> soft
    **    menuItem mapping resource of the same resource ID as the menu.
    **
    **    The menuItem mapping resource is simply a STR# resource that has the same ID as
    **    the menu.  For each menuItem in the menu, you have an entry in the STR# resource.
    **    For example:  If you have a menu of ID 130, then you need a STR# menu of ID 130.
    **    If you want menuItem #1 to have a soft ID of 100, you put a decimal 100 in the
    **    first position of the STR# resource.
    **
    **    DoMenuCommand can handle the menu item any way it sees fit.
    **
    **    __________
    **
    **    Also see:    MapMenuItem, UnmapMenuItem. */



/********** Window.c **********/

void        CalcFrameRgn(FileRecHndl frHndl, WindowPtr window, RgnHandle rgn);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework to calculate the frame region.
    **
    **    INPUT:    frHndl        Document reference to calc frame region for.
    **            window        Window to calc frame region for.
    **    IN/OUT:    rgn            Region to return frame region in.
    **
    **    You are passed an empty region.  You are supposed to add any custom frame
    **    parts that this document uses.  Typically there are no frame portions, as
    **    they are accounted for in other ways.  The scrollbars and grow icon will
    **    automatically be contributed to the calculation of the frame region.
    **    If you use sidebars, these are also added in automatically.  This is only
    **    used if the frame region is more complicated than can automatically be
    **    handled.  So, almost always, you will simply leave the region empty. */

void        ContentClick(WindowPtr window, EventRecord *event, Boolean firstCLick);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework to let app handle content click.
    **
    **    INPUT:    window        Window content click belongs to.
    **            event        Event record holding content click.
    **            firstClick    True if window is marked as first-click window, and it is.
    **
    **    This is called (by DoContentClick) when a mouse-down event occurs in the content of
    **    a window.  Other applications might want to call FindControl, TEClick, etc., to
    **    further process the click. */


Boolean        ContentKey(WindowPtr window, EventRecord *event, Boolean *passThrough);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework to let app handle keypress.
    **
    **    INPUT:    window            Window keypress may belongs to.
    **            event            Event record holding keypress.
    **            passThrough        Return true if key should be passed to next window.
    **    RESULT:    Boolean            If key handled, return true.
    **
    **    This is called (by DoContentClick) when a mouse-down event occurs in the content of
    **    a window.  Other applications might want to call FindControl, TEClick, etc., to
    **    further process the click.
    **    DoKeyDown is first called by the application.  Then if the key isn’t a menu
    **    key, DoKeyDown calls this code.  Here are the rules for this function:
    **
    **    1)    If you handle the key, return(true).  This completes the key handling.
    **    2)    If you don’t handle the key, you return false.  However, there are two
    **        situations for not handling the key:
    **            a) You want someone else to.
    **            b) You want nobody else to look at the key.
    **        This is what the boolean passThrough is for.  If you wish the next window
    **        to have a look at the key, set the boolean passThrough to true.  passThrough
    **        is already initialized to false, which is the common case, so you only have
    **        to worry about setting it true.
    **
    **    If you have a window that never processes keys and always passes them through,
    **    just set the contentKeyProc to nil.  This will indicate to the application
    **    framework that all keys should be passed through this window.  DTS.Draw has
    **    such a window.  Its palette window doesn’t accept keys.  They are passed through
    **    to document windows. */

void        DrawFrame(FileRecHndl frHndl, WindowPtr window, Boolean activate);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework to let app draw frame.
    **
    **    INPUT:    window        Window content click belongs to.
    **            event        Event record holding content click.
    **            firstClick    True if window is marked as first-click window, and it is.
    **
    **    Draw application specific content (Called by DoDrawFrame).
    **
    **    If your application has any custom frame areas, or if it uses sidebars,
    **    this is the function that you would put the frame drawing code.  The
    **    document scrollbars and grow icon drawing is handled by DTS.framework.
    **    Just do the sidebar and custom areas here. */

OSErr        FreeDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework to let app free up related memory.
    **
    **    INPUT:    frHndl        File reference going away.
    **
    **    Frees up any application-specific memory in the document.  This is called by
    **    DoFreeDocument, which is called by DisposeDocument.  The application would
    **    call DisposeDocument, not DoFreeDocument or FreeDocument directly.
    **
    **    The document may have a bunch of handles off the main handle of the document.
    **    This is where they are freed.  DisposeDocument calls this prior to releasing
    **    the ram for the main handle of the document, so release everything else
    **    here, or you will have a memory leak.
    **
    **    NOTE:    Calling DefaultFreeDocument frees up all memory used by a
    **            hierarchical document (see TreeObj package). */

OSErr        FreeWindow(FileRecHndl frHndl, WindowPtr window);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework to let app free up related memory.
    **
    **    INPUT:    window        Window going away.
    **
    **    Any additional window disposal tasks can be handled here. */

OSErr        ImageDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can draw or print doc.
    **
    **    INPUT:    frHndl        Document to image.
    **
    **    The only thing tricky about this function is that it needs to key off of
    **    the global variable gPrintPage.  gPrintPage is the current page that is
    **    being printed.  If gPrintPage is 0, then you are drawing to the window.
    **
    **    For when printing:
    **
    **    If gPrintPage is non-0, that is the page to be printed.  If after imaging
    **    the page there are no more pages, you should set gPrintPage to 0.  This
    **    indicates to the print loop that the end of the document has been reached.
    **    Even if the user indicated in the job dialog to print more pages, setting
    **    gPrintPage to 0 states that the last page has been printed.  This is necessary
    **    because the print loop can’t know when printing is done.  The imaging procedure
    **    is the logical one to state when everything has been imaged. */

OSErr        InitContent(FileRecHndl frHndl, WindowPtr window);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can do more window init.
    **
    **    INPUT:    frHndl        Document to initialize window content for.
    **            window        Window to initialize window content for.
    **
    **    There may be additional content initialization for the window.  At this point,
    **    you have a window, but it is currently invisible.  If you return noErr, then
    **    the window will be set to the state indicated for that window.  Why this function?
    **    You may wish to add controls to the content of the window.  You may have a
    **    TextEdit record in the content.  All of these sort of things can't be created
    **    until there is a window to contain them.  First a document is read in, and then
    **    if the document creation succeeds, a window is created for that document.
    **    At this point we have a document, and we are on our way to having a window.
    **    All that remains is any additional content initialization.  Do it, return
    **    noErr, and everybody's happy.  If something goes wrong here, return the error,
    **    and the incomplete window will be disposed of. */

OSErr        ReadDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can read the document.
    **
    **    INPUT:    frHndl        Document to read.
    **
    **    The sample function below assumes that you are using the hierarchical document package.
    **    If you are, the entire hierarchical document is read in with just this little code.
    **    If you don't use it, you are on your own.  See DTS.StyleChat for an example of an
    **    application that uses the DTS.framework without the hierarchical document package.
    **
    **    OSErr    ReadDocument(FileRecHndl frHndl)
    **    {
    **        OSErr    err;
    **
    **        err = DefaultReadDocument(frHndl);
    **        if (!err)
    **            DefaultReadDocumentFixup(frHndl);
    **
    **        return(err);
    **    }
    */


void        ResizeContent(WindowPtr window, short oldh, short oldv);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can resize window content.
    **
    **    INPUT:    window        Window that has just resized.
    **            oldh        Old horizontal size.
    **            oldv        Old vertical size.
    **
    **    Resize application specific content (Called by ResizeWindow).
    **
    **    This gets called when a user does a zoom or window resizing operation.
    **    It is possible that things in the content need to be resized in conjunction
    **    with the resizing of the window. */

void        ScrollFrame(FileRecHndl frHndl, WindowPtr window, long dh, long dv);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can scroll frame.
    **
    **    INPUT:    frHndl        File reference of scrolling document.
    **            window        Window of scrolling document.
    **            dh            Horizontal delta for scroll.
    **            dv            Vertical delta for scroll.
    **
    **    Some applications may need to scroll the "frame" of the document along
    **    with the document contents.  This is common for applications with rulers,
    **    or other similar sidebar items. */

void        UndoFixup(FileRecHndl frHndl, Point contOrg, Boolean afterUndo);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can manage undo.
    **
    **    INPUT:    frHndl        File reference of document undergoing an undo.
    **            contOrg        Origin that undo was recorded at.
    **            afterUndo    If false, before undo process begun.  If true, completion message.
    **
    **    Since the hierarchical document package isn't used by DTS.StyleChat,
    **    this function actually never gets called. */

Boolean        WindowCursor(FileRecHndl frHndl, WindowPtr window, Point globalPt);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can manage undo.
    **
    **    INPUT:    frHndl        File reference of document to determine cursor for.
    **            window        Window to determine cursor for.
    **            globalPt    Global location of cursor to determine.
    **
    **    This function is where you adjust the cursor to reflect the location in the
    **    document or window.  You have the additional input of gCursorRgn to deal
    **    with.  The way that the cursor handling works is as follows:
    **    1)    The application calls DoWindowCursor.
    **    2)    DoWindowCursor works its way through the windows/documents, front to back.
    **        It looks at the document's windowCursorProc and checks to see if the document
    **        has one.  If the document doesn't have one, then it assumes that that window
    **        always wants an arrow.  If the cursor is over that window, the cursor is set
    **        to an arrow, and we're done.  If the cursor isn't over the window, then the next
    **        window is tried.  If all documents don't have a windowCursorProc, then the cursor
    **        is set to an arrow (for the non-document area of the screen).
    **    3)    If a document has a windowCursorProc, then the proc is called.  The proc's
    **        job is as follows:
    **        a)    If the cursor is over a position that is determined by the window, then
    **            the proc removes other areas from gCursorRgn.  Note that it should not
    **            simply set the area to what it "thinks" is the correct area.  This window
    **            may not be the front-most.  Other windows will have already been subtracted
    **            from gCursorRgn.  The resultant gCursorRgn is the correct cursor area,
    **            and should be passed to WaitNextEvent calls in the application (already the case
    **            in EventLoop.c).  Also, the cursor should be set to the correct cursor, of course.
    **            You should also return true, as the cursor has been determined.
    **        b)    If the cursor is not over a position for this window, then you should
    **            return.  You will either pass back true or false.  If you don't wish
    **            windows behind this window to have a shot at cursor determination, then
    **            return true.  This states that the cursor is "determined".  It is, in the
    **            sense that no further determination will occur.  If you return false, then
    **            other windows get a shot at determining the cursor.
    **
    **    Setting the cursor to the correct cursor isn't as easy as you would expect.
    **    DTS.Lib..framework uses the global gCursorPtr as the reference to the cursor.  This is
    **    fine if the cursor is pointer-based, but if the cursor is resource-based, it is a bit
    **    more of a problem.  What you will need to do is to call DoSetResCursor to make the
    **    resource cursor pointer-based.  DoSetResCursor will set gCursorPtr to nil, and it
    **    also returns the pointer to the permanent copy of the cursor resource.  Just set gCursorPtr
    **    to the return result of DoSetResCursor, and you will be set. */

void        WindowGoneFixup(WindowPtr window);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can have chance to do more.
    **
    **    INPUT:    window        Window that was just removed.  Do related tasks, if any.
    */

OSErr        WriteDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can write the document.
    **
    **    INPUT:    frHndl        Document to write.
    **
    **    The sample function below assumes that you are using the hierarchical document package.
    **    If you are, the entire hierarchical document is written in with just this little code.
    **    If you don't use it, you are on your own.  See DTS.StyleChat for an example of an
    **    application that uses the DTS.framework without the hierarchical document package.
    **
    **    OSErr    WriteDocument(FileRecHndl frHndl)
    **    {
    **        return(DefaultWriteDocument(frHndl));
    **    }
    */

OSErr        DoOpenApplication(void);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can start/restart/edited.
    **
    **    Since an AppsToGo application can be restarted while running, there are certain
    **    tasks that you will need to do in this function.  This function is called at
    **    both startup and restart time, so any initialization code should take this in
    **    mind.  Any code that is related to startup that could be different on a restart
    **    should be placed in this function. */

Boolean        AdjustMenuItems(WindowPtr window, short menuID);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can adjust the menus.
    **
    **    The AppsToGo framework does a lot of the menu handling for you, but there
    **    are certain tasks that must be done by the application.  The framework
    **    iterates through the menuBar, and calls the application for each menu.
    **    The rules for application calling are:
    **    1)    If there are no windows, then AdjustMenuItems is called absolutely.
    **        Given that it can be called with no windows, this should be kept in mind.
    **    2)    If there is a top window, then that document’s AdjustMenuItemsProcPtr field
    **        is referenced to determine where to call.  This field is initialized to
    **        AdjustMenuItems.  This means that, unless you go to some trouble, this
    **        is the only place that the framework will call for menu adjustment.
    **
    **    The following code is from AppWannabe.  It is a sample of what this function
    **    should look like:
    **
    **    Boolean    AdjustMenuItems(WindowPtr window, short menuID)
    **    {
    **        Boolean        redrawMenuBar;
    **        MenuHandle    menu;
    **
    **        redrawMenuBar = false;
    **
    **        switch (menuID) {
    **            case mFile:
    **                redrawMenuBar = DoAdjustFileMenu(window);
    **                break;
    **            case mEdit:
    **                redrawMenuBar = DoAdjustEditMenu(window);
    **                break;
    **            default:
    **                menu = GetMenuHandle(menuID);
    **                if (menu)
    **                    (*menu)->enableFlags |= 0xFFFFFFFEL;
    **                break;
    **        }
    **
    **        return(redrawMenuBar);
    **    }
    */

Boolean        DoMenuItem(WindowPtr window, short menuID, short menuItem);
    /*
    **    ¶ •AppWannabe (Window.c).  Called by framework so app can do the menu command.
    **
    **    INPUT:    window        Window that menu item supposedly belongs to (top non-floater).
    **            menuID        The menuID that the user chose.
    **            menuItem    The menuItem (mapped to a soft ID if available).
    **    RESULT:    Boolean        Return true if handled.  If false is returned, the framework
    **                        may try to do something with it. */



/********** WindowDialog.c **********/

void        DialogCalcFrameRgn(FileRecHndl frHndl, WindowPtr window, RgnHandle rgn);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as CalcFrameRgn, but for dialogs.
    **
    **    Same as CalcFrameRgn, but for dialogs. */

void        DialogContentClick(WindowPtr window, EventRecord *event, Boolean firstClick);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as ContentClick, but for dialogs.
    **
    **    Same as ContentClick, but for dialogs. */

Boolean        DialogContentKey(WindowPtr window, EventRecord *event, Boolean *passThrough);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as ContentKey, but for dialogs.
    **
    **    Same as ContentKey, but for dialogs. */

void        DialogDrawFrame(FileRecHndl frHndl, WindowPtr window, Boolean activate);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as DrawFrame, but for dialogs.
    **
    **    Same as DrawFrame, but for dialogs. */

OSErr        DialogFreeDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as FreeDocument, but for dialogs.
    **
    **    Same as FreeDocument, but for dialogs. */

OSErr        DialogFreeWindow(FileRecHndl frHndl, WindowPtr window);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as FreeWindow, but for dialogs.
    **
    **    Same as FreeWindow, but for dialogs. */

OSErr        DialogImageDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as ImageDocument, but for dialogs.
    **
    **    Same as ImageDocument, but for dialogs. */

OSErr        DialogInitContent(FileRecHndl frHndl, WindowPtr window);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as InitContent, but for dialogs.
    **
    **    Same as InitContent, but for dialogs. */

void        DialogResizeContent(WindowPtr window, short oldh, short oldv);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as ResizeContent, but for dialogs.
    **
    **    Same as ResizeContent, but for dialogs. */

void        DialogScrollFrame(FileRecHndl frHndl, WindowPtr window, long dh, long dv);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as ScrollFrame, but for dialogs.
    **
    **    Same as ScrollFrame, but for dialogs. */

void        DialogUndoFixup(FileRecHndl frHndl, Point contOrg, Boolean afterUndo);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as UndoFixup, but for dialogs.
    **
    **    Same as UndoFixup, but for dialogs. */

Boolean        DialogWindowCursor(FileRecHndl frHndl, WindowPtr window, Point globalPt);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as WindowCursor, but for dialogs.
    **
    **    Same as WindowCursor, but for dialogs. */

void        DialogWindowGoneFixup(WindowPtr window);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as WindowGoneFixup, but for dialogs.
    **
    **    Same as WindowGoneFixup, but for dialogs. */

Boolean        DialogAdjustMenuItems(WindowPtr window, short menuID);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as AdjustMenuItems, but for dialogs.
    **
    **    Same as AdjustMenuItems, but for dialogs. */

Boolean        DialogDoMenuItem(WindowPtr window, short menuID, short menuItem);
    /*
    **    ¶ •AppWannabe (WindowDialog.c).  Same as DoMenuItem, but for dialogs.
    **
    **    Same as DoMenuItem, but for dialogs. */



/********** WindowPalette.c **********/

void        PaletteCalcFrameRgn(FileRecHndl frHndl, WindowPtr window, RgnHandle rgn);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as CalcFrameRgn, but for palettes.
    **
    **    Same as CalcFrameRgn, but for dialogs. */

void        PaletteContentClick(WindowPtr window, EventRecord *event, Boolean firstCLick);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as ContentClick, but for palettes.
    **
    **    Same as ContentClick, but for dialogs. */

Boolean        PaletteContentKey(WindowPtr window, EventRecord *event, Boolean *passThrough);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as ContentKey, but for palettes.
    **
    **    Same as ContentKey, but for dialogs. */

void        PaletteDrawFrame(FileRecHndl frHndl, WindowPtr window, Boolean activate);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as DrawFrame, but for palettes.
    **
    **    Same as DrawFrame, but for dialogs. */

OSErr        PaletteFreeDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as FreeDocument, but for palettes.
    **
    **    Same as FreeDocument, but for dialogs. */

OSErr        PaletteFreeWindow(FileRecHndl frHndl, WindowPtr window);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as FreeWindow, but for palettes.
    **
    **    Same as FreeWindow, but for dialogs. */

OSErr        PaletteImageDocument(FileRecHndl frHndl);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as ImageDocument, but for palettes.
    **
    **    Same as ImageDocument, but for dialogs. */

OSErr        PaletteInitContent(FileRecHndl frHndl, WindowPtr window);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as InitContent, but for palettes.
    **
    **    Same as InitContent, but for dialogs. */

void        PaletteResizeContent(WindowPtr window, short oldh, short oldv);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as ResizeContent, but for palettes.
    **
    **    Same as ResizeContent, but for dialogs. */

void        PaletteScrollFrame(FileRecHndl frHndl, WindowPtr window, long dh, long dv);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as ScrollFrame, but for palettes.
    **
    **    Same as ScrollFrame, but for dialogs. */

void        PaletteUndoFixup(FileRecHndl frHndl, Point contOrg, Boolean afterUndo);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as UndoFixup, but for palettes.
    **
    **    Same as UndoFixup, but for dialogs. */

Boolean        PaletteWindowCursor(FileRecHndl frHndl, WindowPtr window, Point globalPt);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as WindowCursor, but for palettes.
    **
    **    Same as WindowCursor, but for dialogs. */

void        PaletteWindowGoneFixup(WindowPtr window);
    /*
    **    ¶ •AppWannabe (WindowPalette.c).  Same as WindowGoneFixup, but for palettes.
    **
    **    Same as WindowGoneFixup, but for dialogs. */



#endif