Subversion Repositories Kolibri OS

RHD_t rhd;

#pragma pack (push,1)

#pragma pack (pop)

#define CLIP_TOP        1

#define CLIP_BOTTOM     2

#define CLIP_RIGHT      4

#define CLIP_LEFT       8

char _L1OutCode( int x, int y )

/*=================================

    Verify that a point is inside or outside the active viewport.   */

{

    char            flag;

    flag = 0;

    if( x < clip.xmin ) {

        flag |= CLIP_LEFT;

    } else if( x > clip.xmax ) {

        flag |= CLIP_RIGHT;

    }

    if( y < clip.ymin ) {

        flag |= CLIP_TOP;

    } else if( y > clip.ymax ) {

        flag |= CLIP_BOTTOM;

    }

    return( flag );

}

static void line_inter( int * x1, int* y1, int x2, int y2, int x )

/*===========================================================================

    Find the intersection of a line with a boundary of the viewport.

    (x1, y1) is outside and ( x2, y2 ) is inside the viewport.

    NOTE : the signs of denom and ( x - *x1 ) cancel out during division

           so make both of them positive before rounding.   */

{

    int            numer;

    int            denom;

    denom = abs( x2 - *x1 );

    numer = 2L * (long)( y2 - *y1 ) * abs( x - *x1 );

    if( numer > 0 ) {

        numer += denom;                     /* round to closest pixel   */

    } else {

        numer -= denom;

    }

    *y1 += numer / ( denom << 1 );

    *x1 = x;

}

int LineClip( int *x1, int *y1, int *x2, int *y2 )

/*=============================================================

    Clips the line with end points (x1,y1) and (x2,y2) to the active

    viewport using the Cohen-Sutherland clipping algorithm. Return the

    clipped coordinates and a decision drawing flag.    */

{

    char            flag1;

    char            flag2;

    flag1 = _L1OutCode( *x1, *y1 );

    flag2 = _L1OutCode( *x2, *y2 );

    for( ;; ) {

        if( flag1 & flag2 ) break;                  /* trivially outside    */

        if( flag1 == flag2 ) break;                 /* completely inside    */

        if( flag1 == 0 ) {                          /* first point inside   */

            if( flag2 & CLIP_TOP ) {

                line_inter( y2, x2, *y1, *x1, clip.ymin );

            } else if( flag2 & CLIP_BOTTOM ) {

                line_inter( y2, x2, *y1, *x1, clip.ymax );

            } else if( flag2 & CLIP_RIGHT ) {

                line_inter( x2, y2, *x1, *y1, clip.xmax );

            } else if( flag2 & CLIP_LEFT ) {

                line_inter( x2, y2, *x1, *y1, clip.xmin );

            }

            flag2 = _L1OutCode( *x2, *y2 );

        } else {                                    /* second point inside  */

            if( flag1 & CLIP_TOP ) {

                line_inter( y1, x1, *y2, *x2, clip.ymin );

            } else if( flag1 & CLIP_BOTTOM ) {

                line_inter( y1, x1, *y2, *x2, clip.ymax );

            } else if( flag1 & CLIP_RIGHT ) {

                line_inter( x1, y1, *x2, *y2, clip.xmax );

            } else if( flag1 & CLIP_LEFT ) {

                line_inter( x1, y1, *x2, *y2, clip.xmin );

            }

            flag1 = _L1OutCode( *x1, *y1 );

        }

    }

    return( flag1 & flag2 );

}

static void block_inter( int *x, int *y, int flag )

/*======================================================

    Find the intersection of a block with a boundary of the viewport.   */

{

    if( flag & CLIP_TOP ) {

        *y = clip.ymin;

    } else if( flag & CLIP_BOTTOM ) {

        *y = clip.ymax;

    } else if( flag & CLIP_RIGHT ) {

        *x = clip.xmax;

    } else if( flag & CLIP_LEFT ) {

        *x = clip.xmin;

    }

}

int BlockClip( int *x1, int *y1, int *x2, int* y2 )

/*==============================================================

    Clip a block with opposite corners (x1,y1) and (x2,y2) to the

    active viewport based on the Cohen-Sutherland algorithm for line

    clipping. Return the clipped coordinates and a decision drawing

    flag ( 0 draw : 1 don't draw ). */

{

    char            flag1;

    char            flag2;

    flag1 = _L1OutCode( *x1, *y1 );

    flag2 = _L1OutCode( *x2, *y2 );

    for( ;; ) {

        if( flag1 & flag2 ) break;                  /* trivially outside    */

        if( flag1 == flag2 ) break;                 /* completely inside    */

        if( flag1 == 0 ) {

            block_inter( x2, y2, flag2 );

            flag2 = _L1OutCode( *x2, *y2 );

        } else {

            block_inter( x1, y1, flag1 );

            flag1 = _L1OutCode( *x1, *y1 );

        }

    }

    return( flag1 & flag2 );

}

#if 0

typedef struct

{

   int left;

   int top;

   int right;

   int bottom;

}rect_t;

typedef struct _window

{

   struct _window *fd;

   struct _window *bk;

   rect_t pos;

   int width;

   int height;

   int level;

}win_t, *WINPTR;

WINPTR top    = NULL;

WINPTR bottom = NULL;

WINPTR alloc_window()

{

    WINPTR pwin = malloc(sizeof(win_t));

    return pwin;

};

WINPTR create_win(int l, int t, int w, int h, int level)

{

   WINPTR pwin = alloc_window();

   pwin->pos.left   = l;

   pwin->pos.top    = t;

   pwin->pos.right  = l+w-1;

   pwin->pos.bottom = t+h-1;

   pwin->width      = w;

   pwin->height     = h;

   pwin->level      = level;

   return pwin;

};

void insert_window(WINPTR pwin)

{

   WINPTR p = top;

   if(p)

   {

     if(pwin->level <= p->level)

     {

        pwin->fd = p;

        pwin->bk = p->bk;

        pwin->bk->fd = pwin;

        p->bk = pwin;

     }

     else

       p = p->fd;

   }

   else

     top = pwin;

}