ieviewin.c

开放源码的编译器open watcom 1.6.0版的源代码

    IMGED_DIM                   left;
    IMGED_DIM                   top;
    IMGED_DIM                   right;
    IMGED_DIM                   bottom;

    switch ( msg ) {
    case WM_CREATE:
        hframe = _wpi_getframe( hwnd );
        sysmenu = _wpi_getcurrentsysmenu( hframe );
        _wpi_deletemenu( sysmenu, SC_RESTORE, FALSE );
        _wpi_deletemenu( sysmenu, SC_SIZE, FALSE );
        _wpi_deletemenu( sysmenu, SC_MINIMIZE, FALSE );
        _wpi_deletemenu( sysmenu, SC_MAXIMIZE, FALSE );
        _wpi_deletemenu( sysmenu, SC_TASKLIST, FALSE );
#ifdef __OS2_PM__
        _wpi_deletemenu( sysmenu, SC_HIDE, FALSE );
#endif
        _wpi_deletesysmenupos( sysmenu, 1 );
        _wpi_deletesysmenupos( sysmenu, 2 );
        break;

    case WM_PAINT:
        redrawViewWnd( hwnd );
        return 0;

    case WM_MOVE:
        _wpi_getwindowrect( _wpi_getframe(hwnd), &rcview );
        _wpi_getrectvalues( rcview, &left, &top, &right, &bottom );
        ImgedConfigInfo.view_xpos = (short)left;
        ImgedConfigInfo.view_ypos = (short)top;
        break;

    case WM_CLOSE:
        hmenu = GetMenu(_wpi_getframe(HMainWindow));
        if (fOneViewWindow) {
            CheckViewItem(hmenu);
        } else {
            PrintHintTextByID( WIE_USEOPTIONSTOHIDEALL, NULL );
        }
        break;

    case WM_DESTROY:
        hViewWindow = NULL;
        break;

    default:
        return( DefWindowProc( hwnd, msg, wparam, lparam ) );
    }
    return(0);

} /* ViewWindowProc */

/*
 * CheckViewItem - This procedure handles when the view window option is
 *                 selected from the menu.
 */
void CheckViewItem( HMENU hmenu )
{
    WPI_ENUMPROC        fp_enum;

    if ( _wpi_isitemchecked(hmenu, IMGED_VIEW) ) {
        _wpi_checkmenuitem(hmenu, IMGED_VIEW, MF_UNCHECKED, FALSE);
        showState = SW_HIDE;
        ImgedConfigInfo.show_state &= ~SET_SHOW_VIEW;
    } else {
        _wpi_checkmenuitem( hmenu, IMGED_VIEW, MF_CHECKED, FALSE );
        showState = SW_SHOWNORMAL;
        ImgedConfigInfo.show_state |= SET_SHOW_VIEW;
    }

    if ( !hViewWindow ) return;

    ShowWindow( _wpi_getframe(hViewWindow), showState );
    if ( _wpi_iswindow(Instance, ClientWindow) ) {
        fp_enum = _wpi_makeenumprocinstance( ViewEnumProc, Instance );
        _wpi_enumchildwindows( ClientWindow, fp_enum, 0L );
        _wpi_freeprocinstance( fp_enum );
    }
} /* CheckViewItem */

/*
 * GetBkColour - returns the selected background colour.
 */
COLORREF GetBkColour( void )
{
    return( bkgroundColour );
} /* GetBkColour */

/*
 * BkColourEnumProc - used to change the background colour of all mdi
 *                    children
 */
BOOL CALLBACK BkColourEnumProc( HWND hwnd, LONG lparam )
{
    img_node    *node;

    lparam = lparam;

    if (_wpi_getowner(hwnd)) {
        return 1;
    }

    if ( _wpi_isiconic(hwnd) ) {
        return 1;
    }
    node = SelectImage( _wpi_getclient(hwnd) );
    if (!node) return 1;
    if (node->imgtype == BITMAP_IMG) {
        return 1;
    }
    InvalidateRect( _wpi_getclient(hwnd), NULL, FALSE );
    InvalidateRect( node->viewhwnd, NULL, FALSE );
    return 1;
} /* BkColourEnumProc */

/*
 * SetBkColour - Sets the back ground colour (and appropriate inverse)
 */
void SetBkColour( COLORREF colour )
{
    WPI_ENUMPROC        fp_enum;

    if (colour == bkgroundColour) {
        return;
    }

    bkgroundColour = colour;
    if ( !(_wpi_iswindow(Instance, hViewWindow)) ) {
        return;
    }
    InvalidateRect(hViewWindow, NULL, TRUE);

    fp_enum = _wpi_makeenumprocinstance( BkColourEnumProc, Instance );
    _wpi_enumchildwindows( ClientWindow, fp_enum, 0L );
    _wpi_freeprocinstance( fp_enum );
} /* SetBkColour */

/*
 * ResetViewWindow - When a new mdi child is activated, we reset the position
 *                   of the view window.  First we check if only 1 view
 *                   window is being shown, or all of them.
 */
void ResetViewWindow( HWND hwnd )
{
    WPI_RECT    currentloc;
    WPI_RECT    newloc;
    IMGED_DIM   left;
    IMGED_DIM   top;
    IMGED_DIM   right;
    IMGED_DIM   bottom;
    HWND        hframe;
    HWND        currentframe;

    hframe = _wpi_getframe( hwnd );
    if (hViewWindow) {
        currentframe = _wpi_getframe( hViewWindow );
    } else {
        currentframe = NULL;
    }

    if (fOneViewWindow) {
        _wpi_getwindowrect( hframe, &newloc );
        if (hViewWindow) {
            _wpi_getwindowrect( currentframe, &currentloc );
            ShowWindow( currentframe, SW_HIDE );
        } else {
            currentloc = newloc;
        }
        _wpi_getrectvalues( currentloc, &left, &top, &right, &bottom );

        SetWindowPos(hframe,
                     NULL,
                     left,
                     top,
                     _wpi_getwidthrect(newloc),
                     _wpi_getheightrect(newloc),
                     SWP_MOVE | SWP_SIZE | SWP_NOZORDER | SWP_HIDEWINDOW);
        hViewWindow = hwnd;
        ShowWindow( hframe, showState );
    } else {
        hViewWindow = hwnd;
        ShowWindow( hframe, showState );
        _wpi_bringwindowtotop( hframe );
    }
#ifndef __OS2_PM__
    RedrawWindow( hwnd, NULL, NULL, RDW_UPDATENOW );
#endif
} /* ResetViewWindow */

/*
 * HideViewWindow - Hides the view window when a draw pad is minimized.
 */
void HideViewWindow( HWND hwnd )
{
    img_node    *node;

    node = SelectImage(hwnd);
    if (!node) return;
    ShowWindow( _wpi_getframe(node->viewhwnd), SW_HIDE );
} /* HideViewWindow */

/*
 * RePositionViewWnd - Repositions the size of the window (for when a
 *                     different icon is selected.
 */
void RePositionViewWnd( img_node *node )
{
    WPI_RECT    location;
    int         h_adj;
    int         v_adj;
    IMGED_DIM   left;
    IMGED_DIM   top;
    IMGED_DIM   right;
    IMGED_DIM   bottom;
    HWND        frame;
    
    frame = _wpi_getframe( node->viewhwnd );
    _wpi_getwindowrect( frame, &location );

    h_adj = 2 * _wpi_getsystemmetrics(SM_CXDLGFRAME) + 2 * BORDER_WIDTH;
    v_adj = 2 * _wpi_getsystemmetrics(SM_CYDLGFRAME) +
#ifndef __NT__
                _wpi_getsystemmetrics(SM_CYCAPTION) + 2 * BORDER_WIDTH - 1;
#else
                _wpi_getsystemmetrics(SM_CYSMCAPTION) + 2 * BORDER_WIDTH - 1;
#endif
    _wpi_getrectvalues(location, &left, &top, &right, &bottom);
#ifdef __OS2_PM__
    SetWindowPos(frame,
                 NULL,
                 left,
                 bottom,
                 h_adj + node->width,
                 v_adj + node->height,
                 SWP_SIZE | SWP_MOVE | SWP_NOZORDER | SWP_HIDEWINDOW);
#else
    SetWindowPos(node->viewhwnd,
                 NULL,
                 left,
                 top,
                 h_adj + node->width,
                 v_adj + node->height,
                 SWP_SIZE | SWP_MOVE | SWP_NOZORDER | SWP_HIDEWINDOW);
#endif
    hViewWindow = node->viewhwnd;
    ShowWindow( frame, showState );
    SetFocus( HMainWindow );
    InvalidateRect( hViewWindow, NULL, TRUE );
} /* RePositionViewWnd */

/*
 * SetViewWindow - sets whether there is a single view window or multiple
 *                  ones.
 */
void SetViewWindow( BOOL justone )
{
    WPI_ENUMPROC        fp_enum;
    int                 prev_show_state;

    fOneViewWindow = justone;

    if (!justone) {
        if ( _wpi_iswindow(Instance, ClientWindow) ) {
            fp_enum = _wpi_makeenumprocinstance( ViewEnumProc, Instance );
            _wpi_enumchildwindows( ClientWindow, fp_enum, 0L );
            _wpi_freeprocinstance( fp_enum );
        }
    } else {
        prev_show_state = showState;
        showState = SW_HIDE;
        if ( _wpi_iswindow(Instance, ClientWindow) ) {
            fp_enum = _wpi_makeenumprocinstance( ViewEnumProc, Instance );
            _wpi_enumchildwindows( ClientWindow, fp_enum, 0L );
            _wpi_freeprocinstance( fp_enum );
        }
        showState = prev_show_state;
        if ( _wpi_iswindow(Instance, hViewWindow) ) {
            ShowWindow(hViewWindow, showState);
        }
    }
} /* SetViewWindow */

/*
 * ShowViewWindows - toggles the showing of multiple view windows.
 */
void ShowViewWindows( HWND hwnd )
{
    img_node    *node;

    node = GetImageNode( hwnd );
    if (!node) return;

    if (fOneViewWindow) {
        if (hViewWindow != node->viewhwnd) {
            ShowWindow( node->viewhwnd, SW_HIDE );
        } else {
            ShowWindow( node->viewhwnd, showState );
        }
    } else {
        ShowWindow( node->viewhwnd, showState );
    }
} /* ShowViewWindows */

/*
 * IsOneViewWindow - returns TRUE if there is only 1 view window or FALSE
 *                   otherwise
 */
BOOL IsOneViewWindow( void )
{
    return( fOneViewWindow );
} /* IsOneViewWindow */