@DATABASE "pLayerE"
@MASTER   "Work2:AD/Idoc/pLayerE.doc"
@REMARK   This file was created by ADtoHT 2.0 on 28-Apr-97  12:59:58
@REMARK   Do not edit
@REMARK   ADtoHT is © 1993-1995 Christian Stieber

@NODE MAIN "pLayerE.doc"
@TOC "__pOS_Dev.guide/MAIN"

                               @{b}pLayer.library@{ub}

@{"pOS_AddLayerHook()" LINK "pOS_AddLayerHook"}          @{"pOS_AddLayerInfoHook()" LINK "pOS_AddLayerInfoHook"}
@{"pOS_AndRectRegion()" LINK "pOS_AndRectRegion"}         @{"pOS_AndRegionRegion()" LINK "pOS_AndRegionRegion"}
@{"pOS_AndRegionRegionLst()" LINK "pOS_AndRegionRegionLst"}    @{"pOS_BeginLayerUpdate()" LINK "pOS_BeginLayerUpdate"}
@{"pOS_BehindLayer()" LINK "pOS_BehindLayer"}           @{"pOS_CheckVisibleRect()" LINK "pOS_CheckVisibleRect"}
@{"pOS_ClearRegion()" LINK "pOS_ClearRegion"}           @{"pOS_CloneRegion()" LINK "pOS_CloneRegion"}
@{"pOS_ConstructLayer()" LINK "pOS_ConstructLayer"}        @{"pOS_ConstructLayerInfo()" LINK "pOS_ConstructLayerInfo"}
@{"pOS_ConstructRegion()" LINK "pOS_ConstructRegion"}       @{"pOS_CopyLayerToSup()" LINK "pOS_CopyLayerToSup"}
@{"pOS_CopySupToLayer()" LINK "pOS_CopySupToLayer"}        @{"pOS_CreateBehindLayer()" LINK "pOS_CreateBehindLayer"}
@{"pOS_CreateChildLayer()" LINK "pOS_CreateChildLayer"}      @{"pOS_CreateLayerInfo()" LINK "pOS_CreateLayerInfo"}
@{"pOS_CreateRegion()" LINK "pOS_CreateRegion"}          @{"pOS_CreateUpfrontLayer()" LINK "pOS_CreateUpfrontLayer"}
@{"pOS_CreateViClipListFrom()" LINK "pOS_CreateViClipListFrom"}  @{"pOS_DamageLayerInfo()" LINK "pOS_DamageLayerInfo"}
@{"pOS_DamageLayerInfoList()" LINK "pOS_DamageLayerInfoList"}   @{"pOS_DeleteLayer()" LINK "pOS_DeleteLayer"}
@{"pOS_DeleteLayerInfo()" LINK "pOS_DeleteLayerInfo"}       @{"pOS_DeleteRegion()" LINK "pOS_DeleteRegion"}
@{"pOS_DeleteViClipList()" LINK "pOS_DeleteViClipList"}      @{"pOS_DestructLayer()" LINK "pOS_DestructLayer"}
@{"pOS_DestructLayerInfo()" LINK "pOS_DestructLayerInfo"}     @{"pOS_DestructRegion()" LINK "pOS_DestructRegion"}
@{"pOS_EndLayerUpdate()" LINK "pOS_EndLayerUpdate"}        @{"pOS_InstallClipRegion()" LINK "pOS_InstallClipRegion"}
@{"pOS_LockClipLayer()" LINK "pOS_LockClipLayer"}         @{"pOS_LockHideLayer()" LINK "pOS_LockHideLayer"}
@{"pOS_LockLayer()" LINK "pOS_LockLayer"}             @{"pOS_LockLayerInfo()" LINK "pOS_LockLayerInfo"}
@{"pOS_LockLayers()" LINK "pOS_LockLayers"}            @{"pOS_MoveLayerBehindOf()" LINK "pOS_MoveLayerBehindOf"}
@{"pOS_MoveRegion()" LINK "pOS_MoveRegion"}            @{"pOS_MoveRegionLst()" LINK "pOS_MoveRegionLst"}
@{"pOS_MoveSizeLayer()" LINK "pOS_MoveSizeLayer"}         @{"pOS_NAndRectRegion()" LINK "pOS_NAndRectRegion"}
@{"pOS_NAndRegionRegion()" LINK "pOS_NAndRegionRegion"}      @{"pOS_NewSizeRegion()" LINK "pOS_NewSizeRegion"}
@{"pOS_OrRectRegion()" LINK "pOS_OrRectRegion"}          @{"pOS_OrRectRegionILst()" LINK "pOS_OrRectRegionILst"}
@{"pOS_OrRegionRegion()" LINK "pOS_OrRegionRegion"}        @{"pOS_RemLayerHook()" LINK "pOS_RemLayerHook"}
@{"pOS_RemLayerInfoHook()" LINK "pOS_RemLayerInfoHook"}      @{"pOS_ScrollLayer()" LINK "pOS_ScrollLayer"}
@{"pOS_SortRegionLst()" LINK "pOS_SortRegionLst"}         @{"pOS_UnlockClipLayer()" LINK "pOS_UnlockClipLayer"}
@{"pOS_UnlockHideLayer()" LINK "pOS_UnlockHideLayer"}       @{"pOS_UnlockLayer()" LINK "pOS_UnlockLayer"}
@{"pOS_UnlockLayerInfo()" LINK "pOS_UnlockLayerInfo"}       @{"pOS_UnlockLayers()" LINK "pOS_UnlockLayers"}
@{"pOS_UpfrontLayer()" LINK "pOS_UpfrontLayer"}          @{"pOS_WhichLayer()" LINK "pOS_WhichLayer"}
@{"pOS_XOrRectRegion()" LINK "pOS_XOrRectRegion"}         

@ENDNODE
@NODE "pOS_ConstructRegion" "pLayer.library/pOS_ConstructRegion()"
@{b}

    NAME@{ub}
        pOS_ConstructRegion -- initializes a structure for the administration
                     of areas@{b}

    SYNOPSIS@{ub}
        pOS_ConstructRegion(region);
                 @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_ConstructRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}

    FUNCTION@{ub}
        Initializes the administrative structure for area pieces.
        In the region an unlimited number of area pieces can be
        administered that NEVER overlap each other.
        In the end @{"pOS_DestructRegion()" LINK "pOS_DestructRegion"} must be called to free
        the entire memory.@{b}

    INPUTS@{ub}
        region - structure to initialize@{b}

    RESULT@{ub}@{b}

    WARNING@{ub}
        The region-data is 'read-only' and may only be modified via
        the library functions.@{b}

    SEE ALSO@{ub}
        @{"pOS_DestructRegion" LINK "pOS_DestructRegion"}, @{"pOS_CreateRegion" LINK "pOS_CreateRegion"}

@ENDNODE
@NODE "pOS_DestructRegion" "pLayer.library/pOS_DestructRegion()"
@{b}

    NAME@{ub}
        pOS_DestructRegion -- end administration, free data@{b}

    SYNOPSIS@{ub}
        pOS_DestructRegion(region);
                 @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_DestructRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}

    FUNCTION@{ub}
        Free all dynamically allocated data.
        'region' is not freed.@{b}

    INPUTS@{ub}
        region - structure to clear@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}
        @{"pOS_ConstructRegion" LINK "pOS_ConstructRegion"}, @{"pOS_DeleteRegion" LINK "pOS_DeleteRegion"}

@ENDNODE
@NODE "pOS_CreateRegion" "pLayer.library/pOS_CreateRegion()"
@{b}

    NAME@{ub}
        pOS_CreateRegion -- generate a region-structure@{b}

    SYNOPSIS@{ub}
        region = pOS_CreateRegion();
         @{"_R_D0" LINK "pExec/Types.h/File" 37}

        @{"__ARID__" LINK "pExec/Types.h/File" 155} @{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}* pOS_CreateRegion();@{b}

    FUNCTION@{ub}
        Generates and initializes a region-structure.@{b}

    INPUTS@{ub}@{b}

    RESULT@{ub}
        region - structure generated or @{"NULL" LINK "pExec/Types.h/File" 117}@{b}

    SEE ALSO@{ub}
        @{"pOS_ConstructRegion" LINK "pOS_ConstructRegion"}, @{"pOS_DeleteRegion" LINK "pOS_DeleteRegion"}

@ENDNODE
@NODE "pOS_DeleteRegion" "pLayer.library/pOS_DeleteRegion()"
@{b}

    NAME@{ub}
        pOS_DeleteRegion -- delete a region structure@{b}

    SYNOPSIS@{ub}
        pOS_DeleteRegion(region);
                @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_DeleteRegion(@{"__ARID__" LINK "pExec/Types.h/File" 155} @{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}


    FUNCTION@{ub}
        The region and all data administered by it are freed.@{b}

    INPUTS@{ub}
        region - structure to delete@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}
        @{"pOS_DestructRegion" LINK "pOS_DestructRegion"}, @{"pOS_CreateRegion" LINK "pOS_CreateRegion"}

@ENDNODE
@NODE "pOS_OrRectRegionILst" "pLayer.library/pOS_OrRectRegionILst()"
@{b}

    NAME@{ub}
        pOS_OrRectRegionILst -- add a rectangle to the region@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_OrRectRegionILst(region,rectangle,list);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}        @{"_R_A0" LINK "pExec/Types.h/File" 28}      @{"_R_A1" LINK "pExec/Types.h/File" 29}    @{"_R_A2" LINK "pExec/Types.h/File" 30}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_OrRectRegionILst(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,
                     const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*,
                     @{"struct pOS_List" LINK "pExec/List.h/File" 26}*);@{b}

    FUNCTION@{ub}
        Adds an area to the region. All new area pieces are stored in
        the 'list'. This function never generates overlapping area pieces.@{b}

    INPUTS@{ub}
        region     - structure
        rectangle - area to add
        list    - result, new pOS_RegionRectangle@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_OrRectRegion" "pLayer.library/pOS_OrRectRegion()"
@{b}

    NAME@{ub}
        pOS_OrRectRegion -- add a rectangle to the region@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_OrRectRegion(region,rectangle);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}          @{"_R_A0" LINK "pExec/Types.h/File" 28}    @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_OrRectRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*);@{b}


    FUNCTION@{ub}
        Adds an area to the region.@{b}

    INPUTS@{ub}
        region     - structure
        rectangle - area to add@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}
        @{"pOS_OrRectRegionILst" LINK "pOS_OrRectRegionILst"}

@ENDNODE
@NODE "pOS_OrRegionRegion" "pLayer.library/pOS_OrRegionRegion()"
@{b}

    NAME@{ub}
        pOS_OrRegionRegion -- add a region to the region@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_OrRegionRegion(srcRegion,dstRegion);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}        @{"_R_A0" LINK "pExec/Types.h/File" 28}     @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_OrRegionRegion(const @{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}


    FUNCTION@{ub}
        Adds all area pieces of 'srcRegion' to 'dstRegion'.@{b}

    INPUTS@{ub}
        srcRegion - source region that is to be added
        dstRegion - destination, this region will be extended@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}
        @{"pOS_OrRectRegionILst" LINK "pOS_OrRectRegionILst"}

@ENDNODE
@NODE "pOS_AndRectRegion" "pLayer.library/pOS_AndRectRegion()"
@{b}

    NAME@{ub}
        pOS_AndRectRegion -- generates intersection@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_AndRectRegion(region,rectangle);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}          @{"_R_A0" LINK "pExec/Types.h/File" 28}    @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_AndRectRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*);@{b}

    FUNCTION@{ub}
        All area pieces that are located outside of 'rectangle' are cut
        from the 'region'.@{b}

    INPUTS@{ub}
        region     - structure
        rectangle - only this area inside the region remains@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_AndRegionRegion" "pLayer.library/pOS_AndRegionRegion()"
@{b}

    NAME@{ub}
        pOS_AndRegionRegion -- generate intersection of two regions@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_AndRegionRegion(XRegion,region);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}           @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_AndRegionRegion(const @{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}


    FUNCTION@{ub}
        All area pieces that are not also contained in 'XRegion' are cut
        from 'region'.@{b}

    INPUTS@{ub}
        XRegion - areas to be compared
        region   - intersection@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_NAndRectRegion" "pLayer.library/pOS_NAndRectRegion()"
@{b}

    NAME@{ub}
        pOS_NAndRectRegion -- cut a window from a region@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_NAndRectRegion(region,rectangle);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}           @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_NAndRectRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*);@{b}

    FUNCTION@{ub}
        The area 'rectangle' is cut from the 'region'.@{b}

    INPUTS@{ub}
        region     - structure
        rectangle - 'Window' to cut@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_MoveRegion" "pLayer.library/pOS_MoveRegion()"
@{b}

    NAME@{ub}
        pOS_MoveRegion -- move a region@{b}

    SYNOPSIS@{ub}
        pOS_MoveRegion(region, dx,   dy);
                  @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_D0" LINK "pExec/Types.h/File" 37} @{"_R_D1" LINK "pExec/Types.h/File" 38}

        pOS_MoveRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,@{"SLONG" LINK "pExec/Types.h/File" 90} dx,@{"SLONG" LINK "pExec/Types.h/File" 90} dy);@{b}

    FUNCTION@{ub}
        Moves all area pieces from the region.@{b}

    INPUTS@{ub}
        region - structure
        dx     - offset in horizontal direction
        dy     - offset in vertical direction@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_MoveRegionLst" "pLayer.library/pOS_MoveRegionLst()"
@{b}

    NAME@{ub}
        pOS_MoveRegionLst -- move pOS_RegionRectangle@{b}

    SYNOPSIS@{ub}
        pOS_MoveRegionLst(list,dx,   dy);
                  @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_D0" LINK "pExec/Types.h/File" 37} @{"_R_D1" LINK "pExec/Types.h/File" 38}

        pOS_MoveRegionLst(@{"struct pOS_List" LINK "pExec/List.h/File" 26}*,@{"SLONG" LINK "pExec/Types.h/File" 90} dx,@{"SLONG" LINK "pExec/Types.h/File" 90} dy);@{b}

    FUNCTION@{ub}
        Moves all nodes of the list.@{b}

    INPUTS@{ub}
        list - list of type (@{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *)
        dx   - offset in horizontal direction
        dy   - offset in vertical direction@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_NAndRegionRegion" "pLayer.library/pOS_NAndRegionRegion()"
@{b}

    NAME@{ub}
        pOS_NAndRegionRegion -- cut a region from a region@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_NAndRegionRegion(XRegion,region);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}         @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_NAndRegionRegion(const @{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}

    FUNCTION@{ub}
        All area pieces that are also contained in 'XRegion' are cut from 'region'.@{b}

    INPUTS@{ub}
        XRegion - region to cut out
        region   - region to modify@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_XOrRectRegion" "pLayer.library/pOS_XOrRectRegion()"
@{b}

    NAME@{ub}
        pOS_XOrRectRegion -- inverts an area@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_XOrRectRegion(region,rectangle);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}           @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_XOrRectRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*);@{b}

    FUNCTION@{ub}
        The whole area inside of 'rectangle' is inverted in 'region'. Existing
        area pieces are removed and spaces are filled.@{b}

    INPUTS@{ub}
        region     - structure
        rectangle - this area is inverted inside of 'region'@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}
        @{"pOS_OrRectRegionILst" LINK "pOS_OrRectRegionILst"}

@ENDNODE
@NODE "pOS_ClearRegion" "pLayer.library/pOS_ClearRegion()"
@{b}

    NAME@{ub}
        pOS_ClearRegion -- remove all area pieces@{b}

    SYNOPSIS@{ub}
        pOS_ClearRegion(region,list);
              @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_A1" LINK "pExec/Types.h/File" 29}

        pOS_ClearRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*,@{"struct pOS_List" LINK "pExec/List.h/File" 26}*);@{b}

    FUNCTION@{ub}
        All administered area pieces are deleted from 'list'
        (member of @{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *). The memory pool is
        referenced via 'region'.@{b}

    INPUTS@{ub}
        region - indirect reference to memory-pool
        list   - list of nodes (pOS_RegionRectangle *)@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_AndRegionRegionLst" "pLayer.library/pOS_AndRegionRegionLst()"
@{b}

    NAME@{ub}
        pOS_AddRegionRegionLst -- build intersection of two regions@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_AndRegionRegionLst(aList,bList,cList,pool);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}          @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_A1" LINK "pExec/Types.h/File" 29} @{"_R_A2" LINK "pExec/Types.h/File" 30} @{"_R_A3" LINK "pExec/Types.h/File" 31}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_AndRegionRegionLst(
            const @{"struct pOS_List" LINK "pExec/List.h/File" 26}*, const @{"struct pOS_List" LINK "pExec/List.h/File" 26}*,
            @{"struct pOS_List" LINK "pExec/List.h/File" 26}*, @{"struct pOS_MemPool" LINK "pExec/Memory.h/File" 74}*);@{b}

    FUNCTION@{ub}
        New nodes (@{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *) are generated. Their area
        is contained in 'aList' and 'bList'.@{b}

    INPUTS@{ub}
        aList - first set of areas to be compared
           Node: (const @{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *)
        bList - second set of areas to be compared
           Node: (const @{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *)
        cList - initialized new list to hold the result
        pool  - memory-pool for the new area pieces (cList)
           (@{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *)@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}
        @{"pOS_OrRectRegionILst" LINK "pOS_OrRectRegionILst"}

@ENDNODE
@NODE "pOS_NewSizeRegion" "pLayer.library/pOS_NewSizeRegion()"
@{b}

    NAME@{ub}
        pOS_NewSizeRegion -- re-calculates the Region->Bounds@{b}

    SYNOPSIS@{ub}
        pOS_NewSizeRegion(region);
                @{"_R_A0" LINK "pExec/Types.h/File" 28}

        pOS_NewSizeRegion(@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}

    FUNCTION@{ub}
        The whole area in the region is mapped in rg_Bounds.@{b}

    INPUTS@{ub}
        region - structure@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_SortRegionLst" "pLayer.library/pOS_SortRegionLst()"
@{b}

    NAME@{ub}
        pOS_SortRegionLst -- sort area pieces@{b}

    SYNOPSIS@{ub}
        pOS_SortRegionLst(list,  dx,  dy);
               @{"_R_A0" LINK "pExec/Types.h/File" 28} @{"_R_D0" LINK "pExec/Types.h/File" 37} @{"_R_D1" LINK "pExec/Types.h/File" 38}

        pOS_SortRegionLst(@{"struct pOS_List" LINK "pExec/List.h/File" 26}*,@{"SLONG" LINK "pExec/Types.h/File" 90} dx,@{"SLONG" LINK "pExec/Types.h/File" 90} dy);@{b}

    FUNCTION@{ub}
        Sorts all area pieces according to 'dx' and 'dy'@{b}

    INPUTS@{ub}
        list  - list of (@{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *) nodes
        dx,dy - soting rule@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CloneRegion" "pLayer.library/pOS_CloneRegion()"
@{b}

    NAME@{ub}
        pOS_CloneRegion -- copy area pieces@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_CloneRegion(list,region);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}        @{"_R_A0" LINK "pExec/Types.h/File" 28} @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} = pOS_CloneRegion(const @{"struct pOS_List" LINK "pExec/List.h/File" 26}*,@{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}

    FUNCTION@{ub}
        All area pieces from 'list' are copied and added to 'region'. No
        checking for overlaps is done. ATTENTION: if area pieces overlap,
        the region is destroyed. This function only makes sense with an
        empty region.@{b}

    INPUTS@{ub}
        list   - list of (const @{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *) nodes
        region - region for the new nodes and memory-pool for management@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_ConstructLayerInfo" "pLayer.library/pOS_ConstructLayerInfo()"
@{b}

    NAME@{ub}
        pOS_ConstructLayerInfo -- initialization@{b}

    SYNOPSIS@{ub}
        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_ConstructLayerInfo(LayerInfo);
                     @{"_R_A0" LINK "pExec/Types.h/File" 28}

        pOS_ConstructLayerInfo(@{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*);@{b}

    FUNCTION@{ub}
        internal@{b}

    INPUTS@{ub}@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_DestructLayerInfo" "pLayer.library/pOS_DestructLayerInfo()"
@{b}

    NAME@{ub}
        pOS_DestructLayerInfo -- free data@{b}

    SYNOPSIS@{ub}
        pOS_DestructLayerInfo(LayerInfo);
                 @{"_R_A0" LINK "pExec/Types.h/File" 28}

        pOS_DestructLayerInfo(@{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*);@{b}

    FUNCTION@{ub}
        internal@{b}

    INPUTS@{ub}@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CreateLayerInfo" "pLayer.library/pOS_CreateLayerInfo()"
@{b}

    NAME@{ub}
        pOS_CreateLayerInfo -- create LayerInfo@{b}

    SYNOPSIS@{ub}
        LayerInfo = pOS_CreateLayerInfo();
         @{"_R_D0" LINK "pExec/Types.h/File" 37}

        @{"__ARID__" LINK "pExec/Types.h/File" 155} @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}* pOS_CreateLayerInfo();@{b}

    FUNCTION@{ub}
        Generates a LayerInfo structure.@{b}

    INPUTS@{ub}@{b}

    RESULT@{ub}
        LayerInfo structure or @{"NULL" LINK "pExec/Types.h/File" 117} if out of memory@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_DeleteLayerInfo" "pLayer.library/pOS_DeleteLayerInfo()"
@{b}

    NAME@{ub}
        pOS_DeleteLayerInfo -- delete a LayerInfo@{b}

    SYNOPSIS@{ub}
        pOS_DeleteLayerInfo(LayerInfo);
                   @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_DeleteLayerInfo(@{"__ARID__" LINK "pExec/Types.h/File" 155} @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*);@{b}


    FUNCTION@{ub}
        The LayerInfo is deleted. Before you have to make sure that
        no layers are open any longer.@{b}

    INPUTS@{ub}
        LayerInfo - structure to delete@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_ConstructLayer" "pLayer.library/pOS_ConstructLayer()"
@{b}

    NAME@{ub}
        pOS_ConstructLayer -- initialization@{b}

    SYNOPSIS@{ub}
        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_ConstructLayer(Layer);
                 @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_ConstructLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        internal@{b}

    INPUTS@{ub}@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_DestructLayer" "pLayer.library/pOS_DestructLayer()"
@{b}

    NAME@{ub}
        pOS_DestructLayer -- free data@{b}

    SYNOPSIS@{ub}
        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_DestructLayer(Layer);
                 @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_DestructLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}


    FUNCTION@{ub}
        internal@{b}

    INPUTS@{ub}@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CreateBehindLayer" "pLayer.library/pOS_CreateBehindLayer()"
@{b}

    NAME@{ub}
        pOS_CreateBehindLayer -- create bottom level layer@{b}

    SYNOPSIS@{ub}
        Layer = pOS_CreateBehindLayer(LayerInfo,GfxMap,rectangle,flags,superGfx);
         @{"_R_D0" LINK "pExec/Types.h/File" 37}                @{"_R_A0" LINK "pExec/Types.h/File" 28}    @{"_R_A1" LINK "pExec/Types.h/File" 29}   @{"_R_A2" LINK "pExec/Types.h/File" 30}   @{"_R_D0" LINK "pExec/Types.h/File" 37}   @{"_R_A3" LINK "pExec/Types.h/File" 31}

            @{"__ARID__" LINK "pExec/Types.h/File" 155} @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}* pOS_CreateBehindLayer(
                @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*, @{"struct pOS_GfxMap" LINK "pGFX/GfxMap.h/File" 18}*,
                const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*, @{"ULONG" LINK "pExec/Types.h/File" 91}, @{"struct pOS_GfxMap" LINK "pGFX/GfxMap.h/File" 18}*);@{b}

    FUNCTION@{ub}
        Create a new layer in 'LayerInfo' that is supposed to be at the bottom.
        The new layer draws to 'GfxMap' and has the size of 'rectangle'.
        If 'superGfx' is specified, all invisible area pieces are temporarily
        stored in this map. The application does not get a IDCMP_RefreshWindow
        message.@{b}

    INPUTS@{ub}
        LayerInfo - layer becomes a member of LayerInfo
        GfxMap     - the layer is supposed to draw in this map
        rectangle - initial size of the layer
        flags   - (enum pOS_LayerFlags) properties
        superGfx  - @{"NULL" LINK "pExec/Types.h/File" 117} or a GfxMap of its own@{b}

    RESULT@{ub}
        Layer structure or @{"NULL" LINK "pExec/Types.h/File" 117} if out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CreateUpfrontLayer" "pLayer.library/pOS_CreateUpfrontLayer()"
@{b}

    NAME@{ub}
        pOS_CreateUpfrontLayer -- create a top level layer@{b}

    SYNOPSIS@{ub}
        Layer = pOS_CreateUpfrontLayer(LayerInfo,GfxMap,rectangle,flags,superGfx);
         @{"_R_D0" LINK "pExec/Types.h/File" 37}            @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}  @{"_R_A2" LINK "pExec/Types.h/File" 30}    @{"_R_D0" LINK "pExec/Types.h/File" 37}   @{"_R_A3" LINK "pExec/Types.h/File" 31}

            @{"__ARID__" LINK "pExec/Types.h/File" 155} @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}* pOS_CreateUpfrontLayer(
                @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*, @{"struct pOS_GfxMap" LINK "pGFX/GfxMap.h/File" 18}*,
                const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*, @{"ULONG" LINK "pExec/Types.h/File" 91}, @{"struct pOS_GfxMap" LINK "pGFX/GfxMap.h/File" 18}*);@{b}

    FUNCTION@{ub}
        A new layer is created in 'LayerInfo' that is supposed to be at the top.
        The new layer draws to 'GfxMap' and has the size of 'rectangle'. If
        'superGfx' is specified, all invisible area pieces will be temporarily
        stored in this map. The application does not get a IDCMP_RefreshWindow
        message.@{b}

    INPUTS@{ub}
        LayerInfo - layer becomes a member of LayerInfo
        GfxMap     - the layer is supposed to draw in this map
        rectangle - initial size of the layer
        flags   - (enum pOS_LayerFlags) properties
        superGfx  - @{"NULL" LINK "pExec/Types.h/File" 117} or a GfxMap of its own@{b}

    RESULT@{ub}
        Layer structure or @{"NULL" LINK "pExec/Types.h/File" 117} if out of memory@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_DeleteLayer" "pLayer.library/pOS_DeleteLayer()"
@{b}

    NAME@{ub}
        pOS_DeleteLayer -- remove layer and free data@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_DeleteLayer(Layer);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}        @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_DeleteLayer(@{"__ARID__" LINK "pExec/Types.h/File" 155} @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        Remove a layer previously created with @{"pOS_CreateBehindLayer()" LINK "pOS_CreateBehindLayer"}
        or @{"pOS_CreateUpfrontLayer()" LINK "pOS_CreateUpfrontLayer"}.@{b}

    INPUTS@{ub}
        Layer - layer to delete@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_LockLayer" "pLayer.library/pOS_LockLayer()"
@{b}

    NAME@{ub}
        pOS_LockLayer -- lock gfx data@{b}

    SYNOPSIS@{ub}
        pOS_LockLayer(Layer);
                @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_LockLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        Every access to the gfx layer data has to begin with
        locking this layer. The lock may only persist for a short time.@{b}

    INPUTS@{ub}
        Layer - layer to lock@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_UnlockLayer" "pLayer.library/pOS_UnlockLayer()"
@{b}

    NAME@{ub}
        pOS_UnlockLayer -- unlock layer gfx data@{b}

    SYNOPSIS@{ub}
        pOS_UnlockLayer(Layer);
                  @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_UnlockLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        Unlock a previously locked layer.@{b}

    INPUTS@{ub}
        Layer - structure@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_LockLayerInfo" "pLayer.library/pOS_LockLayerInfo()"
@{b}

    NAME@{ub}
        pOS_LockLayerInfo -- lock layer management@{b}

    SYNOPSIS@{ub}
        pOS_LockLayerInfo(LayerInfo);
                 @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_LockLayerInfo(@{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*);@{b}

    FUNCTION@{ub}
        Before the reconstruction of one or more layers the layers management
        (LayerInfo) has to be locked. This lock does not prevent that another
        task may draw in a layer.@{b}

    INPUTS@{ub}
        LayerInfo - structure@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_UnlockLayerInfo" "pLayer.library/pOS_UnlockLayerInfo()"
@{b}

    NAME@{ub}
        pOS_UnlockLayerInfo -- unlock layer management@{b}

    SYNOPSIS@{ub}
        pOS_UnlockLayerInfo(LayerInfo);
                   @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_UnlockLayerInfo(@{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*);@{b}

    FUNCTION@{ub}
        Unlock a previously locked LayerInfo.@{b}

    INPUTS@{ub}
        LayerInfo - structure@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_DamageLayerInfo" "pLayer.library/pOS_DamageLayerInfo()"
@{b}

    NAME@{ub}
        pOS_DamageLayerInfo -- mark an area as invalid@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_DamageLayerInfo(LayerInfo,rectangle,lyFirst,lyLast);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}         @{"_R_A0" LINK "pExec/Types.h/File" 28}     @{"_R_A1" LINK "pExec/Types.h/File" 29}     @{"_R_A2" LINK "pExec/Types.h/File" 30}    @{"_R_A3" LINK "pExec/Types.h/File" 31}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_DamageLayerInfo(
              @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*,const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*,
              const @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,const @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        All layers beginning from 'lyFirst' and touching 'rectangle'
        become invalid at the intersections. A simple-refresh-layer
        sets the LAYERF_Refresh bit and will probably expand the
        damage list. In the super-layer the invalid gfx area is
        immediately copied from the SuperGfxMap.@{b}

    INPUTS@{ub}
        LayerInfo - structure
        rectangle - area to mark
        lyFirst   - begin marking from this layer
               @{"NULL" LINK "pExec/Types.h/File" 117} => do not process anything
        lyLast     - break condition, this layer will not be processed
               @{"NULL" LINK "pExec/Types.h/File" 117} => process to the last layer@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        At function call all layers and the LayerInfo have
        to be locked (@{"pOS_LockLayers()" LINK "pOS_LockLayers"})@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_DamageLayerInfoList" "pLayer.library/pOS_DamageLayerInfoList()"
@{b}

    NAME@{ub}
        pOS_DamageLayerInfoList --@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_DamageLayerInfoList(LayerInfo,list, lyFirst,lyLast);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}            @{"_R_A0" LINK "pExec/Types.h/File" 28}     @{"_R_A1" LINK "pExec/Types.h/File" 29}  @{"_R_A2" LINK "pExec/Types.h/File" 30}    @{"_R_A3" LINK "pExec/Types.h/File" 31}


        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_DamageLayerInfoList(
              @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*,const @{"struct pOS_List" LINK "pExec/List.h/File" 26}*,
              const @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,const @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        See @{"pOS_DamageLayerInfo()" LINK "pOS_DamageLayerInfo"}@{b}

    INPUTS@{ub}
        LayerInfo - structure
        list    - areas to mark, nodes (const pOS_RegionRectangle *)
        lyFirst   - begin marking from this layer
               @{"NULL" LINK "pExec/Types.h/File" 117} => do not process anything
        lyLast     - break condition, this layer will not be processed
               @{"NULL" LINK "pExec/Types.h/File" 117} => process to the last layer@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        At function call all layers and the LayerInfo
        have to be locked (@{"pOS_LockLayers()" LINK "pOS_LockLayers"})@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_MoveSizeLayer" "pLayer.library/pOS_MoveSizeLayer()"
@{b}

    NAME@{ub}
        pOS_MoveSizeLayer -- moves and enlarges the layer@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_MoveSizeLayer(Layer,  dx,  dy,   dw,   dh);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}           @{"_R_A0" LINK "pExec/Types.h/File" 28} @{"_R_D0" LINK "pExec/Types.h/File" 37} @{"_R_D1" LINK "pExec/Types.h/File" 38} @{"_R_D2" LINK "pExec/Types.h/File" 39} @{"_R_D3" LINK "pExec/Types.h/File" 40}


        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_MoveSizeLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"SLONG" LINK "pExec/Types.h/File" 90},@{"SLONG" LINK "pExec/Types.h/File" 90},@{"SLONG" LINK "pExec/Types.h/File" 90},@{"SLONG" LINK "pExec/Types.h/File" 90});@{b}

    FUNCTION@{ub}
        Moves and enlarges the layer.@{b}

    INPUTS@{ub}
        Layer - layer to modify
        dx    - horizontal offset
        dy    - vertical offset
        dw    - change in width
        dh    - change in height@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_WhichLayer" "pLayer.library/pOS_WhichLayer()"
@{b}

    NAME@{ub}
        pOS_WhichLayer -- determines the layer at position@{b}

    SYNOPSIS@{ub}
        Layer = pOS_WhichLayer(LayerInfo, x,   y);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}           @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_D0" LINK "pExec/Types.h/File" 37} @{"_R_D1" LINK "pExec/Types.h/File" 38}

        @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}* pOS_WhichLayer(@{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*,@{"SLONG" LINK "pExec/Types.h/File" 90},@{"SLONG" LINK "pExec/Types.h/File" 90});@{b}

    FUNCTION@{ub}
        Determines the layer visible at position (x,y).@{b}

    INPUTS@{ub}
        LayerInfo - structure
        x,y     - position to determine@{b}

    RESULT@{ub}
        Layer at position (x,y) or @{"NULL" LINK "pExec/Types.h/File" 117}@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_LockLayers" "pLayer.library/pOS_LockLayers()"
@{b}

    NAME@{ub}
        pOS_LockLayers -- lock everything@{b}

    SYNOPSIS@{ub}
        pOS_LockLayers(LayerInfo);
              @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_LockLayers(@{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*);@{b}

    FUNCTION@{ub}
        All layers are locked, no one can make any output or
        modifications. This is needed in some cases, like moving
        layers, changing layer depth, creating layer or deleting layer.@{b}

    INPUTS@{ub}
        LayerInfo - structure@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_UnlockLayers" "pLayer.library/pOS_UnlockLayers()"
@{b}

    NAME@{ub}
        pOS_UnlockLayers -- unlock everything@{b}

    SYNOPSIS@{ub}
        pOS_UnlockLayers(LayerInfo);
                @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_UnlockLayers(@{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*);@{b}

    FUNCTION@{ub}
        Unlock previously locked layers (@{"pOS_LockLayers" LINK "pOS_LockLayers"})@{b}

    INPUTS@{ub}
        LayerInfo - structure@{b}

    RESULT@{ub}@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_BehindLayer" "pLayer.library/pOS_BehindLayer()"
@{b}

    NAME@{ub}
        pOS_BehindLayer - move layer to background@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_BehindLayer(Layer);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}         @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_BehindLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        Move layer to the bottom.@{b}

    INPUTS@{ub}
        Layer - layer to move down@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_UpfrontLayer" "pLayer.library/pOS_UpfrontLayer()"
@{b}

    NAME@{ub}
        pOS_UpfrontLayer -- move layer to the front@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_UpfrontLayer(Layer);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}         @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_UpfrontLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        The layer is moved to the front.@{b}

    INPUTS@{ub}
        Layer - layer to move up@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_AddLayerHook" "pLayer.library/pOS_AddLayerHook()"
@{b}

    NAME@{ub}
        pOS_AddLayerHook -- activate new callback@{b}

    SYNOPSIS@{ub}
        pOS_AddLayerHook(Layer,Callback,drawMode);
              @{"_R_A0" LINK "pExec/Types.h/File" 28} @{"_R_A1" LINK "pExec/Types.h/File" 29}  @{"_R_D0" LINK "pExec/Types.h/File" 37}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_AddLayerHook(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"struct pOS_Callback" LINK "pExec/CallBack.h/File" 17}*,@{"ULONG" LINK "pExec/Types.h/File" 91});@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer  - layer affected
        Callback - function description
        drawMode - 0 == no refresh, 1 == callback is drawn immediately@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_RemLayerHook" "pLayer.library/pOS_RemLayerHook()"
@{b}

    NAME@{ub}
        pOS_RemLayerHook -- remove callback@{b}

    SYNOPSIS@{ub}
        pOS_RemLayerHook(Layer,Callback);
              @{"_R_A0" LINK "pExec/Types.h/File" 28} @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_RemLayerHook(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"struct pOS_Callback" LINK "pExec/CallBack.h/File" 17}*);@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer  - layer affected
        Callback - function description
        drawMode - 0 == no refresh, 1 == callback is drawn immediately@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_BeginLayerUpdate" "pLayer.library/pOS_BeginLayerUpdate()"
@{b}

    NAME@{ub}
        pOS_BeginLayerUpdate -- calculates the area to be refreshed@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_BeginLayerUpdate(Layer,list);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}        @{"_R_A0" LINK "pExec/Types.h/File" 28}    @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_BeginLayerUpdate(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,const @{"struct pOS_List" LINK "pExec/List.h/File" 26}*);@{b}

    FUNCTION@{ub}
        The damage list is used to calculate which layer area has to be
        refreshed. To only draw this area, a special clipping is inserted
        between pOS_BeginLayerUpdate() and @{"pOS_EndLayerUpdate()" LINK "pOS_EndLayerUpdate"}.
        By specifying a ClipList 'list', the area to be drawn will be AND
        connected to the list.@{b}

    INPUTS@{ub}
        Layer - refresh layer
        list - @{"NULL" LINK "pExec/Types.h/File" 117} or nodes (const @{"struct pOS_RegionRectangle" LINK "pLayer/Region.h/File" 21} *)@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_EndLayerUpdate" "pLayer.library/pOS_EndLayerUpdate()"
@{b}

    NAME@{ub}
        pOS_EndLayerUpdate -- activate normal display@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_EndLayerUpdate(Layer,done);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}           @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_D0" LINK "pExec/Types.h/File" 37}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_EndLayerUpdate(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"ULONG" LINK "pExec/Types.h/File" 91});@{b}

    FUNCTION@{ub}
        Finish the refresh procedure
        e.g.
         @{"pOS_BeginLayerUpdate" LINK "pOS_BeginLayerUpdate"}(ly,@{"NULL" LINK "pExec/Types.h/File" 117})
           ... Draw
         pOS_EndLayerUpdate(ly,@{"TRUE" LINK "pExec/Types.h/File" 121})

        or

         @{"pOS_BeginLayerUpdate" LINK "pOS_BeginLayerUpdate"}(ly,@{"NULL" LINK "pExec/Types.h/File" 117})
           ... Draw - 1
         pOS_EndLayerUpdate(ly,@{"FALSE" LINK "pExec/Types.h/File" 122})

         @{"pOS_BeginLayerUpdate" LINK "pOS_BeginLayerUpdate"}(ly,List)
           ... Draw - 2
         pOS_EndLayerUpdate(ly,@{"TRUE" LINK "pExec/Types.h/File" 121})@{b}

    INPUTS@{ub}
        Layer -
        done  - @{"TRUE" LINK "pExec/Types.h/File" 121}: refresh procedure is ready, all damage data is deleted
           @{"FALSE" LINK "pExec/Types.h/File" 122}: the damage data remains@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CreateViClipListFrom" "pLayer.library/pOS_CreateViClipListFrom()"
@{b}

    NAME@{ub}
        pOS_CreateViClipListFrom -- calculates view clips@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_CreateViClipListFrom(LayerInfo,firstLy,breakMode,refRect);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}              @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}   @{"_R_D0" LINK "pExec/Types.h/File" 37}    @{"_R_A2" LINK "pExec/Types.h/File" 30}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_CreateViClipListFrom(
              @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*,const @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,
              @{"BOOL" LINK "pExec/Types.h/File" 99},const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*);@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        LayerInfo - structure
        firstLy   - begin from this layer (must not be @{"NULL" LINK "pExec/Types.h/File" 117})
        breakMode - @{"TRUE" LINK "pExec/Types.h/File" 121}: only modify the first layer
        refRect   - @{"NULL" LINK "pExec/Types.h/File" 117} or filter instruction@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        At function call all layers and the LayerInfo
        have to be locked (@{"pOS_LockLayers()" LINK "pOS_LockLayers"})@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_DeleteViClipList" "pLayer.library/pOS_DeleteViClipList()"
@{b}

    NAME@{ub}
        pOS_DeleteViClipList -- delete view clips@{b}

    SYNOPSIS@{ub}
        pOS_DeleteViClipList(LayerInfo,firstLy,breakMode);
                     @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}  @{"_R_D0" LINK "pExec/Types.h/File" 37}


        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_DeleteViClipList(
              @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*,const @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"BOOL" LINK "pExec/Types.h/File" 99});@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        LayerInfo - structure
        firstLy   - begin from this layer (must not be @{"NULL" LINK "pExec/Types.h/File" 117})
        breakMode - @{"TRUE" LINK "pExec/Types.h/File" 121}: only process the first layer@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        At function call all layers and the LayerInfo
        have to be locked (@{"pOS_LockLayers()" LINK "pOS_LockLayers"})@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_InstallClipRegion" "pLayer.library/pOS_InstallClipRegion()"
@{b}

    NAME@{ub}
        pOS_InstallClipRegion -- additionally clip the layer@{b}

    SYNOPSIS@{ub}
        region = pOS_InstallClipRegion(Layer,region);
         @{"_R_D0" LINK "pExec/Types.h/File" 37}                @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}

            @{"struct pOS_Region" LINK "pLayer/Region.h/File" 30} *pOS_InstallClipRegion(
              @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,const @{"struct pOS_Region" LINK "pLayer/Region.h/File" 30}*);@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer  - layer to process
        region - new clip-region or @{"NULL" LINK "pExec/Types.h/File" 117} => no clipping@{b}

    RESULT@{ub}
        previously set region, may be @{"NULL" LINK "pExec/Types.h/File" 117}@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CreateChildLayer" "pLayer.library/pOS_CreateChildLayer()"
@{b}

    NAME@{ub}
        pOS_CreateChildLayer --@{b}

    SYNOPSIS@{ub}
        Layer = pOS_CreateChildLayer(GfxMap,rectangle,flags,layer,superGfx);
         @{"_R_D0" LINK "pExec/Types.h/File" 37}              @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}     @{"_R_D0" LINK "pExec/Types.h/File" 37} @{"_R_A2" LINK "pExec/Types.h/File" 30}  @{"_R_A3" LINK "pExec/Types.h/File" 31}

        @{"__ARID__" LINK "pExec/Types.h/File" 155} @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}* pOS_CreateChildLayer(
              @{"struct pOS_GfxMap" LINK "pGFX/GfxMap.h/File" 18}*,const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*,
              @{"ULONG" LINK "pExec/Types.h/File" 91},@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"struct pOS_GfxMap" LINK "pGFX/GfxMap.h/File" 18}*);@{b}

    FUNCTION@{ub}
        See @{"pOS_CreateUpfrontLayer" LINK "pOS_CreateUpfrontLayer"}@{b}

    INPUTS@{ub}
        GfxMap     - the layer is supposed to draw in this map
        rectangle - initial size of the layer. child layer MUST be
               inside of the mother
        flags   - (enum pOS_LayerFlags) properties
        layer   - mother-layer
        superGfx  - @{"NULL" LINK "pExec/Types.h/File" 117} ot GfxMap of its own@{b}

    RESULT@{ub}
        new layer or @{"NULL" LINK "pExec/Types.h/File" 117} if out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_MoveLayerBehindOf" "pLayer.library/pOS_MoveLayerBehindOf()"
@{b}

    NAME@{ub}
        pOS_MoveLayerBehindOf -- modify layer depth@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_MoveLayerBehindOf(layer,refLayer);
         @{"_R_D0" LINK "pExec/Types.h/File" 37}            @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_MoveLayerBehindOf(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,const @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}
        The layer will be put behind 'refLayer'.@{b}

    INPUTS@{ub}
        layer  - layer to move
        refLayer - referring layer@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_ScrollLayer" "pLayer.library/pOS_ScrollLayer()"
@{b}

    NAME@{ub}
        pOS_ScrollLayer -- move layer gfx@{b}

    SYNOPSIS@{ub}
        pOS_ScrollLayer(Layer, dx,  dy);
                  @{"_R_A0" LINK "pExec/Types.h/File" 28} @{"_R_D0" LINK "pExec/Types.h/File" 37} @{"_R_D1" LINK "pExec/Types.h/File" 38}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_ScrollLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"SLONG" LINK "pExec/Types.h/File" 90} dx,@{"SLONG" LINK "pExec/Types.h/File" 90} dy);@{b}

    FUNCTION@{ub}
        The graphic is moved within the layer. The movement offset can
        be read from (ly_ScrollX, ly_ScrollY). Never write to ly_Scroll.
        All graphics operations interpret the layer movement and care for
        a real movement of the graphics. A mouse-click is also calculated
        via the offsets.@{b}

    INPUTS@{ub}
        Layer - layer to process
        dx,dy - pixel-movement@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CopySupToLayer" "pLayer.library/pOS_CopySupToLayer()"
@{b}

    NAME@{ub}
        pOS_CopySupToLayer -- copy graphics from SuperMap to layer@{b}

    SYNOPSIS@{ub}
        pOS_CopySupToLayer(Layer);
                @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_CopySupToLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer - structure@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        At function call all layers and the LayerInfo
        have to be locked (@{"pOS_LockLayers()" LINK "pOS_LockLayers"})@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CopyLayerToSup" "pLayer.library/pOS_CopyLayerToSup()"
@{b}

    NAME@{ub}
        pOS_CopyLayerToSup -- copy graphics from layer to SuperMap@{b}

    SYNOPSIS@{ub}
        pOS_CopyLayerToSup(Layer);
                @{"_R_A0" LINK "pExec/Types.h/File" 28}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_CopyLayerToSup(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*);@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer - structure@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        At function call all layers and the LayerInfo
        have to be locked (@{"pOS_LockLayers()" LINK "pOS_LockLayers"})@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_LockHideLayer" "pLayer.library/pOS_LockHideLayer()"
@{b}

    NAME@{ub}
        pOS_LockHideLayer -- lock layer and hide it@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_LockHideLayer(Layer,LayerHide,mode);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}           @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_A1" LINK "pExec/Types.h/File" 29}    @{"_R_D0" LINK "pExec/Types.h/File" 37}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_LockHideLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"struct pOS_LayerHide" LINK "pLayer/Clip.h/File" 40}*,@{"ULONG" LINK "pExec/Types.h/File" 91});@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer   - structure
        LayerHide - temporary storage
        mode    -@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_UnlockHideLayer" "pLayer.library/pOS_UnlockHideLayer()"
@{b}

    NAME@{ub}
        pOS_UnlockHideLayer -- recreate layer@{b}

    SYNOPSIS@{ub}
        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_UnlockHideLayer(Layer,LayerHide);
                  @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_UnlockHideLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"struct pOS_LayerHide" LINK "pLayer/Clip.h/File" 40}*);@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer   - structure
        LayerHide - temporary storage@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_CheckVisibleRect" "pLayer.library/pOS_CheckVisibleRect()"
@{b}

    NAME@{ub}
        pOS_CheckVisibleRect -- determines if area is visible@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_CheckVisibleRect(layer,rectangle);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}         @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_CheckVisibleRect(
              const @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,const @{"struct pOS_Rectangle" LINK "pLayer/Rect.h/File" 17}*);@{b}

    FUNCTION@{ub}
        Determines if the area 'rectangle' is visible as a whole or in part.
        If the function returns @{"FALSE" LINK "pExec/Types.h/File" 122}, a drawing operation within 'rectangle'
        will have no visible effect.@{b}

    INPUTS@{ub}
        layer   - layer to check
        rectangle - area to check@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - visible, @{"FALSE" LINK "pExec/Types.h/File" 122} - completely invisible@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_AddLayerInfoHook" "pLayer.library/pOS_AddLayerInfoHook()"
@{b}

    NAME@{ub}
        pOS_AddLayerInfoHook -- insert LayerInfo callback@{b}

    SYNOPSIS@{ub}
        pOS_AddLayerInfoHook(LayerInfo,Callback,drawMode);
                    @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_A1" LINK "pExec/Types.h/File" 29}     @{"_R_D0" LINK "pExec/Types.h/File" 37}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_AddLayerInfoHook(
              @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*,@{"struct pOS_Callback" LINK "pExec/CallBack.h/File" 17}*,@{"ULONG" LINK "pExec/Types.h/File" 91});@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        LayerInfo - structure
        Callback  - function description
        drawMode  - 0 == don't draw, 1 == draw immediately@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_RemLayerInfoHook" "pLayer.library/pOS_RemLayerInfoHook()"
@{b}

    NAME@{ub}
        pOS_RemLayerInfoHook -- remove LayerInfo callback@{b}

    SYNOPSIS@{ub}
        pOS_RemLayerInfoHook(LayerInfo,Callback,drawMode);
                    @{"_R_A0" LINK "pExec/Types.h/File" 28}  @{"_R_A1" LINK "pExec/Types.h/File" 29}     @{"_R_D0" LINK "pExec/Types.h/File" 37}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_RemLayerInfoHook(
              @{"struct pOS_LayerInfo" LINK "pLayer/Clip.h/File" 101}*,@{"struct pOS_Callback" LINK "pExec/CallBack.h/File" 17}*,@{"ULONG" LINK "pExec/Types.h/File" 91});@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        LayerInfo - structure
        Callback  - function description
        drawMode  - 0 == don't draw, 1 == draw immediately@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_LockClipLayer" "pLayer.library/pOS_LockClipLayer()"
@{b}

    NAME@{ub}
        pOS_LockClipLayer -- clip layer faster@{b}

    SYNOPSIS@{ub}
        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_LockClipLayer(Layer,LayerClip,List,  mode);
        @{"_R_D0" LINK "pExec/Types.h/File" 37}           @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}   @{"_R_A2" LINK "pExec/Types.h/File" 30}  @{"_R_D0" LINK "pExec/Types.h/File" 37}

        @{"BOOL" LINK "pExec/Types.h/File" 99} pOS_LockClipLayer(
              @{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"struct pOS_LayerClip" LINK "pLayer/Clip.h/File" 52}*,
              const @{"struct pOS_List" LINK "pExec/List.h/File" 26}*,@{"ULONG" LINK "pExec/Types.h/File" 91});@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer   - layer to clip
        LayerClip - auxiliary data
        List    - list with the new (const pOS_RegionRectangle *)
        mode    - 0@{b}

    RESULT@{ub}
        @{"TRUE" LINK "pExec/Types.h/File" 121} - OK, @{"FALSE" LINK "pExec/Types.h/File" 122} - out of memory@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}

@ENDNODE
@NODE "pOS_UnlockClipLayer" "pLayer.library/pOS_UnlockClipLayer()"
@{b}

    NAME@{ub}
        pOS_UnlockClipLayer - restore fast clipped layer@{b}

    SYNOPSIS@{ub}
        pOS_UnlockClipLayer(Layer,LayerClip);
                 @{"_R_A0" LINK "pExec/Types.h/File" 28}   @{"_R_A1" LINK "pExec/Types.h/File" 29}

        @{"VOID" LINK "pExec/Types.h/File" 83} pOS_UnlockClipLayer(@{"struct pOS_Layer" LINK "pLayer/Clip.h/File" 63}*,@{"struct pOS_LayerClip" LINK "pLayer/Clip.h/File" 52}*);@{b}

    FUNCTION@{ub}@{b}

    INPUTS@{ub}
        Layer   - layer to clip
        LayerClip - auxiliary data@{b}

    RESULT@{ub}@{b}

    NOTE@{ub}
        All semaphores are respected by this function.@{b}

    SEE ALSO@{ub}@{b}

  END@{ub}

@ENDNODE