window.c

高级C语言源程序范例 Source Code from Que publications "Advanced C" Techniques and Aplications ISBN 0

            set_cursor(&first);

            first.y = window->area->bottom;

            xor_rect(window->area,FRAME);

            /* animate window outline */   
            while(event->what != DN_BUTTON_EVENT)
                {
                get_cursor(&last);
                event = get_next_event();

                if(event->where.x < (window->area->left + MIN_WX))
                    delta.x = 0;
                else
                    delta.x = event->where.x - last.x;

                if(event->where.y > (window->area->top - MIN_WY))
                    delta.y = 0;
                else
                    delta.y = event->where.y - last.y;

                if( delta.x != 0 || delta.y != 0)
                    {
                    /* remove old outline */
                    xor_rect(window->area,FRAME);

                    /* set new outline */
                    window->area->right += delta.x;
                    window->area->bottom += delta.y;

                    /* add new outline */
                    xor_rect(window->area,FRAME);
                    }
                }

            /* found new window size */
            xor_rect(window->area,FRAME);

            /* calculate window's change in position */
            delta.x = window->area->right - first.x;
            delta.y = window->area->bottom - first.y;

            /* offset window's regions */
            window->title->right += delta.x;

            window->pane->right += delta.x;
            window->pane->bottom += delta.y;

            window->shape->bbox->right += delta.x;
            window->shape->bbox->bottom += delta.y;

            /* redo window's shape segment
            to reflect new size */
            key = window->shape->data;

            while(key != NULL)
                {
                if(key->type == RECT)
                    {
                    if(key->key.rect->bottom == window->title->bottom)
                        /* do not change title bottom */
                        key->key.rect->right += delta.x;

                    else
                        {
                        key->key.rect->right += delta.x;
                        key->key.rect->bottom += delta.y;
                        }
                    }
                key = key->next;
                }

            /* refresh bit map */
            all_wins( old_rect );
            free(old_rect);

            draw_win( window );
            }
            break;

        case    CLOSE   :
            /* remove window */
            purge_window( window);

            /* refresh */
            all_wins( window->area );

            break;
        }

    /* refresh display */
}

/* window view operation selection menu items */

#define REDUCE  1
#define ENLARGE 2
#define SCROLL  3
#define FIT     4

char    *view_ops[5] =
    {
    "Cancel",
    "Reduce",
    "Enlarge",
    "Scroll",
    "Fit"
    };

/* scroll operation types */
#define S_UP     0
#define S_LEFT   1
#define S_RIGHT  2
#define S_DOWN   3

char    *scroll_ops[4] =
    {
    "Up",
    "Left",
    "Right",
    "Down"
    };

void        view_window(event, window)
event_t     *event;
window_t    *window;
{
int sel, zoom, pan, h, w;
rect_t	*copy_rect();

    /* pop up view modify menu, user selects item */
    sel = pop_up_menu( 5, view_ops );

    switch(sel)
        {
        case  CANCEL    :
            break;

        case  REDUCE    :
            h = window->data_win->right - window->data_win->left;
            w = window->data_win->top - window->data_win->bottom;
            zoom = h > w ? h/10 : w/10;

            inset_rect(window->data_win, -zoom, -zoom);
            draw_win(window);
            break;

        case  ENLARGE   :
            h = window->data_win->right - window->data_win->left;
            w = window->data_win->top - window->data_win->bottom;
            zoom = h < w ? h/10 : w/10;

            inset_rect(window->data_win, zoom, zoom);
            draw_win(window);
            break;

        case  SCROLL    :
            /* pop up scroll menu, user selects item */
            sel = pop_up_menu( 4, scroll_ops );

            h = window->data_win->right - window->data_win->left;
            w = window->data_win->top - window->data_win->bottom;

            switch(sel)
                {
                case    S_LEFT  :
                    pan = h / 3;
                    offset_rect(window->data_win, pan, 0);
                    break;

                case    S_RIGHT :
                    pan = h / 3;
                    offset_rect(window->data_win, -pan, 0);
                    break;

                case    S_UP    :
                    pan = w / 3;
                    offset_rect(window->data_win, 0, -pan);
                    break;

                case    S_DOWN  :
                    pan = w / 3;
                    offset_rect(window->data_win, 0, pan);
                    break;
                }

            /* do scroll */
            draw_win( window );
            break;

        case  FIT       :
            free(window->data_win);
            window->data_win = copy_rect(window->data->bbox);
            draw_win(window);
            break;
        }
}

/*
    window drawing functions

    draw_win(window)
        draws given window

    draw_all()
        draws desktop, then all windows
        from back to front
*/

draw_win( window )
window_t *window;
{
vport_t winport;
rect_t  tr;

    union_rect(&screen,window->area,&tr);
    if( equal_rect(&screen, &tr) == FALSE)
        {
        win_inrect( window, window->area );
        return;
        }

    /* hide cursor */
    hide_cursor();

    /* draw window's shape segment */
    draw_seg(window->shape, the_port);

    if(window->data != NULL)
        {
        /* set up viewport for window's data segment */
        winport.bitmap = window->pane;
        winport.window = window->data_win;
        winport.seg = window->data;

        /* draw window's data segment */
        draw_seg(window->data, &winport);
        }

    /* show cursor */
    show_cursor();
}


draw_all()
{
window_t    *mywin;

    /* hide cursor */
    hide_cursor();
    draw_seg(desk_seg, the_port);

    mywin = back;
    while(mywin != NULL)
        {
        draw_win(mywin);

        /* next higher window */
        mywin = mywin->prev;
        }

    /* show cursor */
    show_cursor();
}

all_wins( inrect )
rect_t  *inrect;
{
window_t    *mywin;
vport_t     winport;

    /* hide cursor */
    hide_cursor();

    /* add small border */
    inset_rect( inrect, -1, -1);

    winport.bitmap = inrect;
    winport.window = inrect;
    draw_seg( desk_seg, &winport);

    mywin = back;
    while(mywin != NULL)
        {
        win_inrect( mywin, inrect );
        /* next higher window */
        mywin = mywin->prev;
        }

    inset_rect(inrect,1,1);

    /* show cursor */
    show_cursor();
}

/*
    refresh window in rectangle
*/

win_inrect( window, rect )
window_t    *window;
rect_t      *rect;
{
vport_t winport;
double  nl, nb, nr, nt, /* normalized display coordinates */
        pw, ph;         /* width and height */
rect_t  sr, pr, wr, tpr, twr;   /* screen, port, and window rect */
rect_t  *copy_rect();

    /* hide cursor */
    hide_cursor();

    /* clip draw rect to screen */
    sect_rect(&screen, rect, &sr);

    /* set up viewport for window's data segment */
    winport.bitmap = copy_rect(&sr);
    offset_rect(winport.bitmap, -1, 0);
    winport.window = &sr;

    /* draw window's shape segment */
    draw_seg(window->shape, &winport);

    free(winport.bitmap);

    if(window->data != NULL)
        {
        if(clip_map( window->pane, window->data_win, &sr, &pr, &wr))
            {
            winport.bitmap = &pr;
            winport.window = &wr;

            /* draw window's data segment */
            draw_seg(window->data, &winport);
            }
        }

    /* show cursor */
    show_cursor();
}

/*
    clip map takes viewport bounds,
    clipping window, and clipping rectangle
    as arguments; then returns new
    viewport bounds and clipping window
*/

clip_map( old_port, old_win, clip_rect, new_port, new_win)
rect_t  *old_port,
        *old_win,
        *clip_rect,
        *new_port,
        *new_win;
{
double  nl, nb, nr, nt, /* normalized display coords */
        pw, ph;         /* width and height */

    if(sect_rect(clip_rect, old_port, new_port))
        {
        pw = (double) (old_port->right - old_port->left);
        ph = (double) (old_port->top - old_port->bottom);
        /* These must never be equal to 0.0! */

        /* convert clipped port to normalized display coordinates */
        nl = ((double) (new_port->left - old_port->left)) / pw;
        nr = ((double) (new_port->right - old_port->left)) / pw;

        nb = ((double) (new_port->bottom - old_port->bottom)) / ph;
        nt = ((double) (new_port->top - old_port->bottom)) / ph;

        /* find new window */
        pw = (double) (old_win->right - old_win->left);
        ph = (double) (old_win->top - old_win->bottom);

        if(nl == 0.0)
            new_win->left = old_win->left;
        else
            new_win->left = old_win->left + (int) ( nl * pw );

        if(nb == 0.0)
            new_win->bottom = old_win->bottom;
        else
            new_win->bottom = old_win->bottom + (int) ( nb * ph );

        if(nr == 1.0)
            new_win->right = old_win->right;
        else
            new_win->right = old_win->left + (int) ( nr * pw );

        if(nt == 1.0)
            new_win->top = old_win->top;
        else
            new_win->top = old_win->bottom + (int) ( nt * ph );

        return(TRUE);
        }
    else
        return(FALSE);
}

/*
    window removal functions

    purge_window(window)
        removes given window from
        linked window list

    purge_all()
        resets window list to be empty

    Note:
        both functions call draw_all()
*/

purge_window(window)
window_t    *window;
{
/*
    remove from doubly linked list
    remove window shape segment
    free window structure from memory

    Note:
        Only the front or active window
        can be purged.

        This does not free the window structure
        or its associated data from memory!
*/

    if(window == back)
        /* last window in list */
        front = back = NULL;
    else
        {
        front->next->prev = NULL;
        front = front->next;
        }

    window->next = window->prev = NULL;
    num_windows--;
}

purge_all()
{
/*
    remove all windows

    Note:
        This does not free window structures
        or their associated data from memory!
*/
    front = back = NULL;

    draw_all();
    num_windows = 0;
}