Return to pathlist.h CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / libsrc

Annotation of 43BSDTahoe/new/X/libibm/libsrc/pathlist.h, revision 1.1

1.1     ! root        1: /* $Header: pathlist.h,v 10.1 86/11/19 10:46:00 jg Exp $ */
        !             2: /* pathlist.h - Constants, macros, typedefs and globals
        !             3:  *              used by PathListConverter()
        !             4:  *
        !             5:  *     Author:
        !             6:  *             Scott Bates
        !             7:  *             Brown University
        !             8:  *             IRIS, Box 1946
        !             9:  *             Providence, RI 02912
        !            10:  *
        !            11:  *
        !            12:  *             Copyright (c) 1986 Brown University
        !            13:  *
        !            14:  * Permission to use, copy, modify and distribute this software and its
        !            15:  * documentation for any purpose and without fee is hereby granted, provided
        !            16:  * that the above copyright notice appear in all copies, and that both
        !            17:  * that copyright notice and this permission notice appear in supporting
        !            18:  * documentation, and that the name of Brown University not be used in
        !            19:  * advertising or publicity pertaining to distribution of the software
        !            20:  * without specific, written prior permission. Brown University makes no
        !            21:  * representations about the suitability of this software for any purpose.
        !            22:  * It is provided "as-is" without express or implied warranty.
        !            23:  */
        !            24: 
        !            25: /*
        !            26:  * Path list Segment structure
        !            27:  */
        !            28: 
        !            29: typedef struct _Segment {
        !            30:        int Index;
        !            31:        int Type;
        !            32:        int Count;
        !            33: } Segment;
        !            34: 
        !            35: /*
        !            36:  * Segment types
        !            37:  */
        !            38: 
        !            39: #define LINE_SEGMENT           0
        !            40: #define OPEN_CURVE_SEGMENT     1
        !            41: #define CLOSED_CURVE_SEGMENT   2
        !            42: 
        !            43: /*
        !            44:  * Default values for segemnt allocation
        !            45:  */
        !            46: 
        !            47: #define INITIAL_SEGMENTS       1024
        !            48: #define ADDITIONAL_SEGMENTS     512
        !            49: 
        !            50: /*
        !            51:  * This macro starts a new segment and when required 
        !            52:  * expands the size of the segment table
        !            53:  */
        !            54: 
        !            55: #define StartNewSegment(type, index, count) {                             \
        !            56:     if(++SegmentIndex == MaxSegments) {                                           \
        !            57:        Segment *TempSeg;                                                  \
        !            58:                                                                           \
        !            59:        MaxSegments += 1 + ADDITIONAL_SEGMENTS;                            \
        !            60:        TempSeg = (Segment *)realloc((caddr_t)SegmentTable,                \
        !            61:                     (unsigned)(MaxSegments * sizeof(Segment)));           \
        !            62:        if(TempSeg == NULL) {                                              \
        !            63:           return(NULL);                                                   \
        !            64:        }                                                                  \
        !            65:         CurrentSegment = &((SegmentTable = TempSeg)[SegmentIndex]);       \
        !            66:     } else {                                                              \
        !            67:        CurrentSegment++;                                                  \
        !            68:     }                                                                     \
        !            69:     CurrentSegment->Index = (index);                                      \
        !            70:     CurrentSegment->Type = (type);                                        \
        !            71:     CurrentSegment->Count = (count);                                      \
        !            72: }
        !            73: 
        !            74: /*
        !            75:  * Defaults for spline vertex buffer allocation
        !            76:  */
        !            77: 
        !            78: #define INITIAL_SPLINE_VERTS   4096
        !            79: #define ADDITIONAL_SPLINE_VERTS        1024
        !            80: 
        !            81: /*
        !            82:  * This macro increases the size of the spline vertex buffer
        !            83:  * if it is to small to handle "VertexCount" entries.
        !            84:  */
        !            85: 
        !            86: #define GrowSplineVertexBuffer(CurrentVertex, VertexCount) {              \
        !            87:        if((SplineVertexIndex + (VertexCount)) > MaxSplineVerts) {         \
        !            88:            Vertex *TempVerts;                                             \
        !            89:                                                                           \
        !            90:            MaxSplineVerts += ((VertexCount) - (MaxSplineVerts -           \
        !            91:                        SplineVertexIndex)) + ADDITIONAL_SPLINE_VERTS;     \
        !            92:                                                                           \
        !            93:            TempVerts = (Vertex *)realloc((caddr_t)SplineVertexBuffer,     \
        !            94:                    (unsigned)(MaxSplineVerts * sizeof(Vertex)));          \
        !            95:             if(TempVerts == NULL) {                                       \
        !            96:                return(NULL);                                              \
        !            97:             }                                                             \
        !            98:            (CurrentVertex) =                                              \
        !            99:                &((SplineVertexBuffer = TempVerts)[SplineVertexIndex]);    \
        !           100:        }                                                                  \
        !           101: }
        !           102: 
        !           103: /*
        !           104:  * Vertex type flags
        !           105:  */
        !           106: 
        !           107: #define VERTEX_TYPE_MASK        0x001C
        !           108: #define LINE                    0x0000
        !           109: #define CURVE                   0x0004
        !           110: #define START_CLOSED_CURVE      0x000C
        !           111: #define END_CLOSED_CURVE        0x0014
        !           112: #define START_OF_CLOSED_POLY    0x8000
        !           113: 
        !           114: /*
        !           115:  * glocal variables
        !           116:  */
        !           117: 
        !           118: static Vertex *SplineVertexBuffer;
        !           119: static int SplineVertexIndex;
        !           120: static int MaxSplineVerts;
        !           121: static int SplineUsed;
        !           122: static Segment *SegmentTable;

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.