Return to lib.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / pads / x11

Annotation of researchv9/jtools/src/pads/x11/lib.c, revision 1.1

1.1     ! root        1: #include "univ.h"
        !             2: 
        !             3: waitMOUSE() { wait(MOUSE); }
        !             4: 
        !             5: char *itoa(n)
        !             6: register n;
        !             7: {
        !             8:        register char *pic = " [-][0-9]* ";
        !             9:        char cip[10];
        !            10:        register char *p = pic, *c;
        !            11: 
        !            12:        *p++ = ' ';
        !            13:        if( n < 0 ) *p++ = '-', n = -n;
        !            14:        *(c = &cip[0]) = '\0';
        !            15:        do {
        !            16:                *++c = "0123456789"[n%10];
        !            17:        } while( n = n/10 );
        !            18:        while( *c ) *p++ = *c--;
        !            19:        *p++ = ' ';
        !            20:        *p = '\0';
        !            21:        return pic;
        !            22: }
        !            23:        
        !            24: dictorder(a,b)
        !            25: register char *a, *b;
        !            26: {
        !            27:        register disc;
        !            28: 
        !            29:        for( ;; ){
        !            30:                if( !*a ) return 1;
        !            31:                if( !*b ) return 0;
        !            32:                if( disc = (*a++|' ')-(*b++|' ') ) return disc<0;
        !            33:        }
        !            34: }
        !            35: #ifdef ASSERT
        !            36: long assertf(l)
        !            37: long l;
        !            38: {
        !            39:        if( l ) return l;
        !            40:        rectf( &display, display.rect, F_XOR );
        !            41:        for( ;; ) pause();
        !            42: }
        !            43: #endif
        !            44: 
        !            45: outline( b, r )
        !            46: register Bitmap *b;
        !            47: Rectangle r;
        !            48: {
        !            49:        segment( b, r.origin, Pt(r.origin.x,--r.corner.y), F_XOR );
        !            50:        segment( b, Pt(--r.corner.x,r.origin.y), r.origin, F_XOR );
        !            51:        segment( b, Pt(r.origin.x,r.corner.y), r.corner, F_XOR );
        !            52:        segment( b, r.corner, Pt(r.corner.x,r.origin.y), F_XOR );
        !            53: }
        !            54: 
        !            55: Rectangle boundrect( q, r )
        !            56: Rectangle q, r;
        !            57: {
        !            58:        q.origin.x = min( q.origin.x, r.origin.x );
        !            59:        q.origin.y = min( q.origin.y, r.origin.y );
        !            60:        q.corner.x = max( q.corner.x, r.corner.x );
        !            61:        q.corner.y = max( q.corner.y, r.corner.y );
        !            62:        return q;
        !            63: }
        !            64: 
        !            65: Rectangle scrollbar( r, from, to, lo, hi )
        !            66: Rectangle r;
        !            67: {
        !            68:        register short rh = r.corner.y - r.origin.y, h = hi-lo;
        !            69:        
        !            70:        r.corner.y -= muldiv(hi-to,rh,h);
        !            71:        r.origin.y += muldiv(from-lo,rh,h);
        !            72:        return r;
        !            73: }
        !            74: 
        !            75: rectinrect( r, s )
        !            76: Rectangle r, s;
        !            77: {
        !            78:        Rectangle clipped;
        !            79: 
        !            80:        clipped = r;
        !            81:        return rectclip(&clipped,s) && eqrect(r, clipped);
        !            82: }
        !            83: 
        !            84: char *FreeSome = "out of terminal memory";
        !            85: 
        !            86: char *Alloc(n)
        !            87: {
        !            88:        char *a;
        !            89: 
        !            90:        if( !(a = alloc(n)) ){
        !            91:                cursswitch( &NoMemory );
        !            92:                InvertKBDrect( FreeSome, "" );
        !            93:                sleep(30);
        !            94:                exit(1);
        !            95:        }
        !            96:        return a;
        !            97: }
        !            98: 
        !            99: char *GCAlloc(n,p)
        !           100: register char **p;
        !           101: {
        !           102:        register unsigned long nbytes = n;
        !           103:        if( !(gcalloc(nbytes, p)) ){
        !           104:                cursswitch( &NoGCMemory );
        !           105:                InvertKBDrect( FreeSome, "" );
        !           106:                sleep(30);
        !           107:                exit(1);
        !           108:        }
        !           109:        while( nbytes>0 ) (*p)[--nbytes] = 0;
        !           110:        return *p;
        !           111: }
        !           112: 
        !           113: GCString( p, s )
        !           114: char **p, *s;
        !           115: {
        !           116:        *p = GCAlloc( strlen(s)+1, p );
        !           117:        strcpy( *p, s );
        !           118: }
        !           119: 
        !           120: Rectangle moverect(source,bound)
        !           121: Rectangle source, bound;
        !           122: {
        !           123:        Rectangle target;
        !           124:        Point base, track;
        !           125:        int b = butts;
        !           126: 
        !           127:        base = mouse.xy;
        !           128:        bound.origin.x += base.x - source.origin.x;
        !           129:        bound.origin.y += base.y - source.origin.y;
        !           130:        bound.corner.x += base.x - source.corner.x;
        !           131:        bound.corner.y += base.y - source.corner.y;
        !           132:        do {
        !           133:                track = mouse.xy;
        !           134:                if( track.x < bound.origin.x ) track.x = bound.origin.x;
        !           135:                if( track.y < bound.origin.y ) track.y = bound.origin.y;
        !           136:                if( track.x > bound.corner.x ) track.x = bound.corner.x;
        !           137:                if( track.y > bound.corner.y ) track.y = bound.corner.y;
        !           138:                outline( &display, target = raddp( source, sub(track,base) ) ); 
        !           139:                jnap(2);
        !           140:                outline( &display, target );
        !           141:        } while( butts == b );
        !           142:        return butts ? source : target;
        !           143: }

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