guisize.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 700 行 · 第 1/2 页

        area->row = screen.row;
        if( dir & RESIZE_UP ) {
            area->height -= diff;
        }
    }
    if( area->col < screen.col ) {
        diff = screen.col - area->col;
        area->col = screen.col;
        if( dir & RESIZE_LEFT ) {
            area->width -= diff;
        }
    }
    diff = 0;
    if( area->height > screen.height ) {
        diff = screen.height - area->height;
    }
    if( area->height < MIN_HEIGHT ) {
        diff = MIN_HEIGHT - area->height;
    }
    area->height += diff;
    if( dir & RESIZE_UP ) {
        area->row -= diff;
    }

    /* do width */
    diff = 0;
    if( area->width > screen.width ) {
        diff = screen.width - area->width;
    }
    if( area->width < MIN_WIDTH ) {
        diff = MIN_WIDTH - area->width;
    }
    area->width += diff;
    if( dir & RESIZE_LEFT ) {
        area->col -= diff;
    }

    diff = area->row + area->height - screen.row - screen.height;
    if( diff > 0 ) {
        if( ( dir & RESIZE_DOWN ) || ( dir & RESIZE_UP ) ) {
            area->height -= diff;
        }
        if( dir & RESIZE_UP ) {
            area->row += diff;
        }
        if( dir == RESIZE_NONE )  {
            area->row -= diff;
        }
    }
    diff = area->col + area->width - screen.col - screen.width;
    if( diff > 0 ) {
        if( ( dir & RESIZE_RIGHT ) || ( dir & RESIZE_LEFT ) ) {
            area->width -= diff;
        }
        if( dir & RESIZE_LEFT ) {
            area->col += diff;
        }
        if( dir == RESIZE_NONE ) {
            area->col -= diff;
        }
    }
}

/*
 * GUIWndMoveSize
 */

bool GUIWndMoveSize( gui_window *wnd, SAREA *new, gui_flags flag,
                     resize_dir dir )
{

    GUICheckArea( new, dir );
    /* if the window has been resized */
    if( ( new->height != wnd->screen.area.height ) ||
        ( new->width != wnd->screen.area.width  ) || ( flag == MINIMIZED ) ) {
        return( SizeWnd( wnd, new, flag, dir ) );
    } else {
        /* if the window has been moved but not resized */
        if( ( new->row != wnd->screen.area.row ) ||
            ( new->col != wnd->screen.area.col ) ) {
            MoveWnd( wnd, new->row - (int)wnd->screen.area.row,
                     new->col - (int)wnd->screen.area.col );
            wnd->flags |= flag;
        } else {
            if( flag != NONE ) {
                wnd->flags |= flag;
                GUIRedrawTitle( wnd );
            }
        }
    }
    return( TRUE );
}

static void CalcIconsDim( gui_window *parent, int *icons_per_row,
                          int *max_rows, SAREA *bound  )
{
    if( parent == NULL ) {
        GUIGetScreenArea( bound );
    } else {
        COPYAREA( parent->use, *bound );
        bound->row += parent->screen.area.row;
        bound->col += parent->screen.area.col;
    }
    *icons_per_row = ( bound->width + 1 ) / ( MIN_WIDTH + 1 );
    *max_rows = ( bound->height + 1 ) / ( MIN_HEIGHT + 1 );
}

static int GetMaxIcons( gui_window *parent )
{
    int         icons_per_row;
    int         max_rows;
    SAREA       bound;

    CalcIconsDim( parent, &icons_per_row, &max_rows, &bound );
    return( icons_per_row * max_rows );
}

void GUICalcIconArea( int num, gui_window *parent, SAREA *new )
{
    int         icon_row;
    int         icons_per_row;
    SAREA       bound;
    int         max_rows;

    CalcIconsDim( parent, &icons_per_row, &max_rows, &bound );

    icon_row = ( num - 1 ) / icons_per_row;
    new->col = bound.col +
               ( MIN_WIDTH + 1 ) * ( num - icon_row * icons_per_row  - 1);
    if( icon_row >= max_rows ) {
        icon_row = icon_row % max_rows;
    }
    new->row = bound.row +
               ( bound.height - MIN_HEIGHT * ( icon_row + 1 ) - icon_row );
    new->width = MIN_WIDTH;
    new->height = MIN_HEIGHT;
}

static bool IconPosUsed( gui_window *curr, int num, gui_window *parent )
{
    SAREA       new;

    GUICalcIconArea( num, parent, &new );
    return( GUIOverlap( &new, &curr->screen.area ) );
}

static void GetIconPos( gui_window *parent, SAREA *new )
{
    gui_window  *curr;
    bool        found;
    int         num;
    int         num_mod;
    int         max_icons;
    int         times_used;

    num = 1;
    if( parent != NULL ) {
        num_mod = 0;
        found = FALSE;
        max_icons = GetMaxIcons( parent );
        while( !found ) {
            if( num - num_mod * max_icons > max_icons ) {
                num_mod++;
            }
            times_used = 0;
            for( curr = parent->child; curr != NULL; curr = curr->sibling ) {
                if( GUI_WND_MINIMIZED( curr ) ) {
                    if( IconPosUsed( curr, num, parent ) ) {
                        times_used++;
                        if( times_used > num_mod ) {
                            break;
                        }
                    }
                }
            }
            if( times_used > num_mod ) {
                num++;
            } else {
                found = TRUE;
            }
        }
    }
    GUICalcIconArea( num, parent, new );
}

static void InitMaxArea( gui_window *parent, SAREA *new )
{
    if( parent == NULL ) {
        GUIGetScreenArea( new );
    } else {
        COPYAREA( parent->use, *new );
        new->row += parent->screen.area.row;
        new->col += parent->screen.area.col;
    }
}

static void SetPrevArea( SAREA *area, gui_window *wnd )
{
    COPYAREA( *area, wnd->prev_area );
    if( wnd->parent != NULL ) {
        wnd->prev_area.row -= wnd->parent->screen.area.row;
        wnd->prev_area.col -= wnd->parent->screen.area.col;
    }
}

void GUIZoomWnd( gui_window *wnd, gui_create_styles action )
{
    SAREA       new;
    gui_flags   flag;
    gui_flags   old;
    bool        minmax;

    minmax = GUI_WND_MAXIMIZED( wnd ) || GUI_WND_MINIMIZED( wnd );
    if( ( action == GUI_NONE ) && minmax ) {
        /* return to previous size */
        new = wnd->prev_area;
        if( wnd->parent != NULL ) {
            new.row += wnd->parent->screen.area.row;
            new.col += wnd->parent->screen.area.col;
        }
        old = wnd->flags;
        if( GUIWndMoveSize( wnd, &new, NONE, RESIZE_DOWN | RESIZE_RIGHT ) ) {
            if( GUI_WND_MINIMIZED( wnd ) ) {
                wnd->flags &= ~MINIMIZED;
                GUIRedrawTitle( wnd );
            }
            if( GUI_WND_MAXIMIZED( wnd ) ) {
                wnd->flags &= ~MAXIMIZED;
                GUIRedrawTitle( wnd );
            }
        } else {
            wnd->flags = old;
        }
    } else {
        if( !( wnd->style & action ) ) {
             return;
        }
        /* make fullsized or minimized */
        if( !minmax ) {
            /* record restore area if not already minimized or maxmized */
            SetPrevArea( &wnd->screen.area, wnd );
        }
        if( action == GUI_MAXIMIZE ) {
            InitMaxArea( wnd->parent, &new );
            flag = MAXIMIZED;
        } else {
            flag = MINIMIZED;
            GetIconPos( wnd->parent, &new );
        }
        old = wnd->flags;
        if( !GUIWndMoveSize( wnd, &new, flag, RESIZE_DOWN | RESIZE_RIGHT ) ) {
            /* resize failed - window is not maximized or minimized */
            wnd->flags = old;
        }
    }
    GUISetSystemMenuFlags( wnd );
    if( action == GUI_MINIMIZE ) {
        GUIEVENTWND( wnd, GUI_ICONIFIED, NULL );
    }
}

bool GUIResizeWindow( gui_window *wnd, gui_rect *rect )
{
    SAREA       area;
    bool        ret;
    bool        hidden;
    gui_coord   newsize;

    if( !GUISetArea( &area, rect, wnd->parent, TRUE, GUI_IS_DIALOG( wnd ) ) ) {
        return( FALSE );
    }
    if( GUI_IS_DIALOG( wnd ) ) {
        ret = GUIResizeDialog( wnd, &area );
        newsize.x = wnd->use.width;
        newsize.y = wnd->use.height;
        GUIScreenToScaleR( &newsize );
        GUIEVENTWND( wnd, GUI_RESIZE, &newsize );
    } else {
        hidden = uivshow( &wnd->screen );
#ifdef HELL_FREEZES_OVER
        if( ret ) {
            ret = GUIWndMoveSize( wnd, &area, GUI_NONE, RESIZE_DOWN | RESIZE_RIGHT );
        }
#else
        ret = GUIWndMoveSize( wnd, &area, GUI_NONE, RESIZE_DOWN | RESIZE_RIGHT );
#endif
        if( hidden ) {
            uivhide( &wnd->screen );
        }
    }
    return( ret );
}

void GUISetRestoredSize( gui_window *wnd, gui_rect *rect )
{
    SAREA       area;

    if( GUI_WND_MAXIMIZED( wnd ) || GUI_WND_MINIMIZED( wnd ) ) {
        if( GUISetArea( &area, rect, wnd->parent, TRUE, FALSE ) ) {
            SetPrevArea( &area, wnd );
        }
    } else {
        GUIResizeWindow( wnd, rect );
    }
}

bool GUIGetRestoredSize( gui_window *wnd, gui_rect *rect )
{
    SAREA       pos;

    COPYAREA( wnd->prev_area, pos );
    if( wnd->parent != NULL ) {
        pos.row += wnd->parent->screen.area.row;
        pos.col += wnd->parent->screen.area.col;
    }
    return ( GUIScreenToScaleRect( &pos, rect ) );
}

void GUIMinimizeWindow( gui_window * wnd )
{
    if( !GUI_WND_MINIMIZED( wnd ) ) {
        GUIZoomWnd( wnd, GUI_MINIMIZE );
    }
}

void GUIMaximizeWindow( gui_window * wnd )
{
    if( !GUI_WND_MAXIMIZED( wnd ) ) {
        GUIZoomWnd( wnd, GUI_MAXIMIZE );
    }
}

void GUIRestoreWindow( gui_window * wnd )
{
    if( GUI_WND_MINIMIZED( wnd ) || GUI_WND_MAXIMIZED( wnd ) ) {
        GUIZoomWnd( wnd, GUI_NONE );
    }
}

bool GUIIsMaximized( gui_window *wnd )
{
    return( ( wnd->flags & MAXIMIZED ) != 0 );
}

bool GUIIsMinimized( gui_window *wnd )
{
    return( ( wnd->flags & MINIMIZED ) != 0 );
}