mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1213 lines
28 KiB
1213 lines
28 KiB
#include <platform.h>
|
|
|
|
#include <sccfi.h>
|
|
#include <sccut.h>
|
|
#include <sccch.h>
|
|
#include <sccvw.h>
|
|
#include <sccd.h>
|
|
|
|
#ifdef SCCFEATURE_DIALOGS
|
|
|
|
#ifdef SCCFEATURE_CLIP
|
|
#include "dlg_mclp.h"
|
|
#endif
|
|
#ifdef SCCFEATURE_PRINT
|
|
#include "dlg_mprt.h"
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#include "oim.h"
|
|
#include "oimstr.h"
|
|
#include "oimnp_w.h"
|
|
#include "oimproc.pro"
|
|
#include "oimdraw.pro"
|
|
#include "oimnp_w.pro"
|
|
|
|
#ifdef WIN32
|
|
HINSTANCE hInst = 0;
|
|
#endif
|
|
|
|
extern VECTOROPT Options;
|
|
|
|
|
|
#ifdef SCCFEATURE_DIALOGS
|
|
#ifdef SCCFEATURE_PRINT
|
|
|
|
HANDLE staticHPrintSample;
|
|
BOOL bPrintMaintainAspect;
|
|
BOOL bPrintBorder;
|
|
|
|
int WIN_ENTRYMOD OIMPrintDlgProc( hDlg, wMsg, wParam, lParam )
|
|
HWND hDlg;
|
|
UINT wMsg;
|
|
WPARAM wParam;
|
|
LPARAM lParam;
|
|
{
|
|
switch ( wMsg )
|
|
{
|
|
case WM_INITDIALOG:
|
|
|
|
staticHPrintSample = LoadBitmap( hInst, MAKEINTRESOURCE(OIM_PSAMPLEBITMAP));
|
|
|
|
/*
|
|
| Center dialog
|
|
*/
|
|
{
|
|
RECT locRect;
|
|
int locX;
|
|
int locY;
|
|
GetWindowRect(hDlg,&locRect);
|
|
locX = (GetSystemMetrics(SM_CXSCREEN) - (locRect.right - locRect.left)) / 2;
|
|
locY = (GetSystemMetrics(SM_CYSCREEN) - (locRect.bottom - locRect.top)) / 2;
|
|
SetWindowPos(hDlg,NULL,locX,locY,0,0,SWP_NOSIZE | SWP_NOZORDER);
|
|
}
|
|
if( Options.bPrintMaintainAspect )
|
|
CheckRadioButton( hDlg, OIMDLG_MAINTAINASPECT, OIMDLG_STRETCH, OIMDLG_MAINTAINASPECT );
|
|
else
|
|
CheckRadioButton( hDlg, OIMDLG_MAINTAINASPECT, OIMDLG_STRETCH, OIMDLG_STRETCH );
|
|
|
|
if( Options.bPrintBorder )
|
|
CheckDlgButton( hDlg, OIMDLG_BORDER, 1 );
|
|
|
|
bPrintBorder = Options.bPrintBorder;
|
|
bPrintMaintainAspect = Options.bPrintMaintainAspect;
|
|
|
|
OIMUpdatePrintSample( hDlg );
|
|
|
|
return TRUE;
|
|
|
|
case WM_PAINT:
|
|
OIMUpdatePrintSample( hDlg );
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
|
|
switch ( wParam )
|
|
{
|
|
|
|
case OIMDLG_MAINTAINASPECT:
|
|
bPrintMaintainAspect = TRUE;
|
|
OIMUpdatePrintSample( hDlg );
|
|
break;
|
|
case OIMDLG_STRETCH:
|
|
bPrintMaintainAspect = FALSE;
|
|
OIMUpdatePrintSample( hDlg );
|
|
break;
|
|
case OIMDLG_BORDER:
|
|
bPrintBorder = IsDlgButtonChecked( hDlg, OIMDLG_BORDER );
|
|
OIMUpdatePrintSample( hDlg );
|
|
break;
|
|
case OIMPRINTBUTTON_HELP:
|
|
//JKXXX UTHelp(OI_DrawingPrintOptions);
|
|
break;
|
|
case IDOK:
|
|
Options.bPrintBorder = bPrintBorder;
|
|
Options.bPrintMaintainAspect = bPrintMaintainAspect;
|
|
DeleteObject(staticHPrintSample);
|
|
EndDialog ( hDlg, TRUE );
|
|
break;
|
|
case IDCANCEL:
|
|
DeleteObject(staticHPrintSample);
|
|
EndDialog ( hDlg, 0 );
|
|
break;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VOID OIMUpdatePrintSample( hDlg )
|
|
HWND hDlg;
|
|
{
|
|
RECT rcSample;
|
|
POINT ptSample;
|
|
HANDLE hOldObj;
|
|
HDC hdc;
|
|
HDC hMemDc;
|
|
WORD wBmpOffset;
|
|
|
|
GetWindowRect( GetDlgItem(hDlg,OIMDLG_PRINTSAMPLE), &rcSample );
|
|
ptSample.x = rcSample.left;
|
|
ptSample.y = rcSample.top+1;
|
|
ScreenToClient( hDlg, &ptSample );
|
|
|
|
hdc = GetDC( hDlg );
|
|
hMemDc = CreateCompatibleDC( hdc );
|
|
|
|
if( bPrintMaintainAspect )
|
|
wBmpOffset = 0;
|
|
else
|
|
wBmpOffset = OIM_SAMPLEBMPHEIGHT;
|
|
|
|
if( bPrintBorder )
|
|
wBmpOffset += 2*OIM_SAMPLEBMPHEIGHT;
|
|
|
|
hOldObj = SelectObject( hMemDc, staticHPrintSample );
|
|
BitBlt(hdc, ptSample.x, ptSample.y, OIM_SAMPLEBMPWIDTH, OIM_SAMPLEBMPHEIGHT, hMemDc, 0, wBmpOffset, SRCCOPY);
|
|
SelectObject( hMemDc, hOldObj );
|
|
|
|
rcSample.top = ptSample.y;
|
|
rcSample.left = ptSample.x;
|
|
rcSample.bottom = ptSample.y + OIM_SAMPLEBMPHEIGHT;
|
|
rcSample.right = ptSample.x + OIM_SAMPLEBMPWIDTH;
|
|
ValidateRect( hDlg, &rcSample );
|
|
|
|
DeleteDC( hMemDc );
|
|
ReleaseDC( hDlg, hdc );
|
|
}
|
|
SHORT OIMDoPrintOptionsNP( DoWop )
|
|
LPSCCDOPTIONINFO DoWop;
|
|
{
|
|
return(DialogBox(hInst, MAKEINTRESOURCE(OIMPRINTDLG_BOX), DoWop->hParentWnd, OIMPrintDlgProc));
|
|
}
|
|
#endif // SCCFEATURE_PRINT
|
|
|
|
#ifdef SCCFEATURE_CLIP
|
|
SHORT OIMDoClipOptionsNP( DoWop )
|
|
LPSCCDOPTIONINFO DoWop;
|
|
{
|
|
return(DialogBox(hInst, MAKEINTRESOURCE(OIMCLIPDLG_BOX), DoWop->hParentWnd, OIMClipDlgProc));
|
|
}
|
|
|
|
int WIN_ENTRYMOD OIMClipDlgProc( hDlg, wMsg, wParam, lParam )
|
|
HWND hDlg;
|
|
UINT wMsg;
|
|
WPARAM wParam;
|
|
LPARAM lParam;
|
|
{
|
|
switch ( wMsg )
|
|
{
|
|
case WM_INITDIALOG:
|
|
|
|
/*
|
|
| Center dialog
|
|
*/
|
|
{
|
|
RECT locRect;
|
|
int locX;
|
|
int locY;
|
|
GetWindowRect(hDlg,&locRect);
|
|
locX = (GetSystemMetrics(SM_CXSCREEN) - (locRect.right - locRect.left)) / 2;
|
|
locY = (GetSystemMetrics(SM_CYSCREEN) - (locRect.bottom - locRect.top)) / 2;
|
|
SetWindowPos(hDlg,NULL,locX,locY,0,0,SWP_NOSIZE | SWP_NOZORDER);
|
|
}
|
|
if( Options.wClipFormats & OIM_BITMAPONCLIP )
|
|
CheckDlgButton( hDlg, BOX_FORMAT_BITMAP, 1 );
|
|
if( Options.wClipFormats & OIM_DIBONCLIP )
|
|
CheckDlgButton( hDlg, BOX_FORMAT_DIB, 1 );
|
|
if( Options.wClipFormats & OIM_PALETTEONCLIP )
|
|
CheckDlgButton( hDlg, BOX_FORMAT_PALETTE, 1 );
|
|
if( Options.wClipFormats & OIM_METAFILEONCLIP )
|
|
CheckDlgButton( hDlg, BOX_FORMAT_METAFILE, 1 );
|
|
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
|
|
switch ( wParam )
|
|
{
|
|
case IDOK:
|
|
Options.wClipFormats = 0;
|
|
if ( IsDlgButtonChecked( hDlg, BOX_FORMAT_BITMAP ) )
|
|
Options.wClipFormats |= OIM_BITMAPONCLIP;
|
|
if ( IsDlgButtonChecked( hDlg, BOX_FORMAT_DIB ) )
|
|
Options.wClipFormats |= OIM_DIBONCLIP;
|
|
if ( IsDlgButtonChecked( hDlg, BOX_FORMAT_PALETTE ) )
|
|
Options.wClipFormats |= OIM_PALETTEONCLIP;
|
|
if ( IsDlgButtonChecked( hDlg, BOX_FORMAT_METAFILE ) )
|
|
Options.wClipFormats |= OIM_METAFILEONCLIP;
|
|
|
|
EndDialog ( hDlg, TRUE );
|
|
break;
|
|
case OIMCLIPBUTTON_HELP:
|
|
//JKXXX UTHelp(OI_DrawingClipOptions);
|
|
break;
|
|
case IDCANCEL:
|
|
EndDialog ( hDlg, 0 );
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
#endif // SCCFEATURE_CLIP
|
|
#endif // SCCFEATURE_DIALOGS
|
|
|
|
|
|
#ifdef SCCFEATURE_MENU
|
|
WORD OIMFillMenuNP( hMenu, wCommandOffset )
|
|
HMENU hMenu;
|
|
WORD wCommandOffset;
|
|
{
|
|
HMENU hPopup;
|
|
BYTE MenuString[OIM_MENUSTRINGMAX];
|
|
WORD i;
|
|
WORD wMag;
|
|
|
|
|
|
hPopup = CreatePopupMenu();
|
|
|
|
if( hPopup == NULL )
|
|
return 0;
|
|
|
|
LoadString( hInst, OIMSTR_SHOWFULL, MenuString, OIM_MENUSTRINGMAX );
|
|
AppendMenu( hMenu, MF_STRING, wCommandOffset + OIMMENU_SHOWFULLSCREEN, MenuString );
|
|
|
|
LoadString( hInst, OIMSTR_NOSCALING, MenuString, OIM_MENUSTRINGMAX );
|
|
AppendMenu( hPopup, (Options.wScaleMode == OIMMENU_ORIGINALSIZE) ? MF_CHECKED|MF_STRING : MF_STRING , wCommandOffset + OIMMENU_ORIGINALSIZE, MenuString );
|
|
|
|
LoadString( hInst, OIMSTR_TOWINDOW, MenuString, OIM_MENUSTRINGMAX );
|
|
AppendMenu( hPopup, (Options.wScaleMode == OIMMENU_FITTOWINDOW) ? MF_CHECKED|MF_STRING : MF_STRING , wCommandOffset + OIMMENU_FITTOWINDOW, MenuString );
|
|
|
|
LoadString( hInst, OIMSTR_TOWIDTH, MenuString, OIM_MENUSTRINGMAX );
|
|
AppendMenu( hPopup, (Options.wScaleMode == OIMMENU_FITTOWIDTH) ? MF_CHECKED|MF_STRING : MF_STRING, wCommandOffset + OIMMENU_FITTOWIDTH, MenuString );
|
|
|
|
LoadString( hInst, OIMSTR_TOHEIGHT, MenuString, OIM_MENUSTRINGMAX );
|
|
AppendMenu( hPopup, (Options.wScaleMode == OIMMENU_FITTOHEIGHT) ? MF_CHECKED|MF_STRING : MF_STRING, wCommandOffset + OIMMENU_FITTOHEIGHT, MenuString );
|
|
|
|
LoadString( hInst, OIMSTR_STRETCH, MenuString, OIM_MENUSTRINGMAX );
|
|
AppendMenu( hPopup, (Options.wScaleMode == OIMMENU_STRETCHTOWINDOW) ? MF_CHECKED|MF_STRING : MF_STRING , wCommandOffset + OIMMENU_STRETCHTOWINDOW, MenuString );
|
|
|
|
LoadString( hInst, OIMSTR_SIZE, MenuString, OIM_MENUSTRINGMAX );
|
|
AppendMenu( hMenu, MF_POPUP|MF_STRING, (WORD)hPopup, MenuString );
|
|
|
|
hPopup = CreatePopupMenu();
|
|
if( hPopup == NULL )
|
|
return 0;
|
|
|
|
wMag = wCommandOffset + OIMMENU_MAGNIFYPOPUP+1;
|
|
|
|
for( i=0; i<OIM_MAXZOOM; i++ )
|
|
{
|
|
wsprintf( (LPSTR) MenuString, "&%d:1", i+1 );
|
|
AppendMenu( hPopup, MF_STRING, wMag++, (LPSTR)MenuString );
|
|
}
|
|
|
|
LoadString( hInst, OIMSTR_MAGNIFY, MenuString, OIM_MENUSTRINGMAX );
|
|
AppendMenu( hMenu, MF_POPUP|MF_STRING, (WORD)hPopup, MenuString );
|
|
|
|
return 1;
|
|
}
|
|
#endif // SCCFEATURE_MENU
|
|
|
|
|
|
#ifdef SCCFEATURE_FULLSCREEN
|
|
WORD OIMShowFullScreenNP( lpDisplay )
|
|
POIM_DISPLAY lpDisplay;
|
|
{
|
|
MSG Msg;
|
|
WNDCLASS wc;
|
|
WORD ret;
|
|
if( !GetClassInfo( hInst, "OIMFullScreen", &wc ) )
|
|
{
|
|
// Register the class for full screen viewing.
|
|
wc.style = CS_GLOBALCLASS;
|
|
wc.lpfnWndProc = OIMFullScreenWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = sizeof( POIM_DISPLAY );
|
|
wc.hInstance = hInst;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = LoadCursor(NULL,IDC_ARROW);
|
|
wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
|
|
wc.lpszMenuName = (LPSTR) NULL;
|
|
wc.lpszClassName = (LPSTR) "OIMFullScreen";
|
|
RegisterClass( &wc );
|
|
}
|
|
|
|
lpDisplay->hwndFullScreen =
|
|
CreateWindow( "OIMFullScreen",
|
|
NULL,
|
|
WS_POPUP | WS_VISIBLE,
|
|
0,
|
|
0,
|
|
lpDisplay->wScreenWidth,
|
|
lpDisplay->wScreenHeight,
|
|
lpDisplay->Gen.hWnd,
|
|
NULL,
|
|
hInst,
|
|
(LPSTR)lpDisplay );
|
|
|
|
if( lpDisplay->hwndFullScreen == NULL )
|
|
{
|
|
ret = 1;
|
|
}
|
|
else
|
|
{
|
|
lpDisplay->wFlags |= OIMF_FULLSCREEN;
|
|
SetFocus( lpDisplay->hwndFullScreen );
|
|
while (lpDisplay->wFlags & OIMF_FULLSCREEN)
|
|
{
|
|
if(PeekMessage(&Msg,0,0,0,PM_NOREMOVE))
|
|
{
|
|
GetMessage ( &Msg, 0, 0, 0 );
|
|
if ( (Msg.hwnd == lpDisplay->hwndFullScreen) ||
|
|
(Msg.message == WM_PAINT) ||
|
|
(Msg.message == WM_ERASEBKGND) )
|
|
{
|
|
TranslateMessage(&Msg);
|
|
DispatchMessage(&Msg);
|
|
}
|
|
}
|
|
}
|
|
DestroyWindow(lpDisplay->hwndFullScreen);
|
|
ret=0;
|
|
}
|
|
UnregisterClass ( "OIMFullScreen", hInst );
|
|
return(ret);
|
|
}
|
|
|
|
|
|
|
|
WIN_ENTRYSC LRESULT WIN_ENTRYMOD WIN_ENTRYMOD OIMFullScreenWndProc( hwnd, message, wParam, lParam )
|
|
HWND hwnd;
|
|
UINT message;
|
|
WPARAM wParam;
|
|
LPARAM lParam;
|
|
{
|
|
POIM_DISPLAY lpDisplay;
|
|
int X, Y;
|
|
LRESULT locRet;
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
|
|
if( message == WM_NCCREATE )
|
|
{
|
|
if ((locRet = DefWindowProc(hwnd, message, wParam, lParam)) != 0)
|
|
SetWindowLong( hwnd, 0, (LONG) ((LPCREATESTRUCT)lParam)->lpCreateParams );
|
|
return( locRet );
|
|
}
|
|
else
|
|
{
|
|
lpDisplay = (POIM_DISPLAY) GetWindowLong( hwnd, 0 );
|
|
|
|
switch( message )
|
|
{
|
|
case WM_PAINT:
|
|
|
|
|
|
hdc = BeginPaint(hwnd, &ps);
|
|
|
|
{
|
|
SHORT nViewX, nViewY;
|
|
if( lpDisplay->Image.hPalette != NULL )
|
|
{
|
|
SelectPalette( hdc, lpDisplay->Image.hPalette, TRUE );
|
|
RealizePalette( hdc );
|
|
}
|
|
if( (DWORD)((DWORD)lpDisplay->Image.wHeight*(DWORD)lpDisplay->wScreenWidth) <
|
|
(DWORD)((DWORD)lpDisplay->Image.wWidth*(DWORD)lpDisplay->wScreenHeight) )
|
|
{
|
|
nViewX = lpDisplay->wScreenWidth;
|
|
nViewY = (WORD)((DWORD)(lpDisplay->Image.wHeight)*(DWORD)(lpDisplay->wScreenWidth)/
|
|
(DWORD)(lpDisplay->Image.wWidth));
|
|
X = 0;
|
|
Y = (lpDisplay->wScreenHeight - (WORD)(nViewY)) / 2;
|
|
}
|
|
else
|
|
{
|
|
nViewY = lpDisplay->wScreenHeight;
|
|
nViewX = (WORD)((DWORD)(lpDisplay->Image.wWidth)*(DWORD)(lpDisplay->wScreenHeight)/
|
|
(DWORD)(lpDisplay->Image.wHeight));
|
|
X = (lpDisplay->wScreenWidth - (WORD)(nViewX)) / 2;
|
|
Y = 0;
|
|
}
|
|
SetMapMode( hdc, MM_ANISOTROPIC );
|
|
VUSetWindowExt( hdc, lpDisplay->nWindowX, lpDisplay->nWindowY );
|
|
VUSetViewportExt( hdc, nViewX, nViewY );
|
|
|
|
VUSetWindowOrg ( hdc, lpDisplay->Image.bbox.left, lpDisplay->Image.bbox.top );
|
|
VUSetViewportOrg ( hdc, X, Y );
|
|
OIMPlayFile ( hdc, NULL, lpDisplay, OIMF_PLAYTOSCREEN );
|
|
|
|
}
|
|
|
|
EndPaint(hwnd, &ps);
|
|
|
|
break;
|
|
|
|
case WM_KEYDOWN:
|
|
case WM_LBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
lpDisplay->wFlags &= ~OIMF_FULLSCREEN;
|
|
break;
|
|
|
|
default:
|
|
return( DefWindowProc(hwnd, message, wParam, lParam) );
|
|
}
|
|
}
|
|
}
|
|
#endif //SCCFEATURE_FULLSCREEN
|
|
|
|
|
|
HANDLE CreateFontRtnNP ( hDC, lpObject )
|
|
HDC hDC;
|
|
LPBYTE lpObject;
|
|
{
|
|
#ifdef WIN32
|
|
PSOLOGFONT psolf;
|
|
LOGFONT lf;
|
|
SHORT i;
|
|
psolf = (PSOLOGFONT)lpObject;
|
|
lf.lfHeight = psolf->lfHeight;
|
|
lf.lfWidth = psolf->lfWidth;
|
|
lf.lfEscapement = psolf->lfEscapement;
|
|
lf.lfOrientation = psolf->lfOrientation;
|
|
lf.lfWeight = psolf->lfWeight;
|
|
lf.lfItalic = psolf->lfItalic;
|
|
lf.lfUnderline = psolf->lfUnderline;
|
|
lf.lfStrikeOut = psolf->lfStrikeOut;
|
|
lf.lfCharSet = psolf->lfCharSet;
|
|
lf.lfOutPrecision = psolf->lfOutPrecision;
|
|
lf.lfClipPrecision = psolf->lfClipPrecision;
|
|
lf.lfQuality = psolf->lfQuality;
|
|
lf.lfPitchAndFamily = psolf->lfPitchAndFamily;
|
|
for ( i=0; i < LF_FACESIZE; i++ )
|
|
lf.lfFaceName[i] = psolf->lfFaceName[i];
|
|
return ( (HANDLE)CreateFontIndirect( (LPLOGFONT)&lf));
|
|
#else
|
|
return ( (HANDLE)CreateFontIndirect( (LPLOGFONT)lpObject));
|
|
#endif
|
|
}
|
|
|
|
HANDLE CreatePenRtnNP ( hDC, lpObject )
|
|
HDC hDC;
|
|
LPBYTE lpObject;
|
|
{
|
|
#ifdef WIN32
|
|
PSOLOGPEN psolp;
|
|
LOGPEN lp;
|
|
psolp = (PSOLOGPEN)lpObject;
|
|
lp.lopnStyle = psolp->loPenStyle;
|
|
lp.lopnWidth.x = psolp->loWidth.x;
|
|
lp.lopnWidth.y = psolp->loWidth.y;
|
|
lp.lopnColor = psolp->loColor;
|
|
|
|
return ( (HANDLE)CreatePenIndirect((LPLOGPEN)&lp));
|
|
|
|
#else
|
|
return ( (HANDLE)CreatePenIndirect( (LPLOGPEN)lpObject));
|
|
#endif
|
|
}
|
|
|
|
HANDLE CreateBrushRtnNP ( hDC, lpObject )
|
|
HDC hDC;
|
|
LPBYTE lpObject;
|
|
{
|
|
#ifdef WIN32
|
|
PSOLOGBRUSH psolb;
|
|
LOGBRUSH lb;
|
|
psolb = (PSOLOGBRUSH)lpObject;
|
|
|
|
lb.lbStyle = psolb->lbStyle;
|
|
lb.lbColor = psolb->lbColor;
|
|
lb.lbHatch = psolb->lbHatch;
|
|
return ( (HANDLE)CreateBrushIndirect((LPLOGBRUSH)&lb));
|
|
|
|
#else
|
|
return ( (HANDLE)CreateBrushIndirect((LPLOGBRUSH)lpObject));
|
|
#endif
|
|
}
|
|
|
|
HPALETTE VUSetupPalette( hdc, lpDisplay, lpNumColors, bRgbTo256Ok )
|
|
HDC hdc;
|
|
POIM_DISPLAY lpDisplay;
|
|
LPWORD lpNumColors;
|
|
BOOL bRgbTo256Ok;
|
|
{
|
|
CHSECTIONINFO SecInfo;
|
|
RGBQUAD far * pSrcEntry;
|
|
LPPALETTEENTRY pNewEntry;
|
|
LPLOGPALETTE lpPalette;
|
|
WORD i;
|
|
HANDLE hMem;
|
|
WORD wNumColors;
|
|
HPALETTE hPalette;
|
|
BOOL bBlankPalette;
|
|
|
|
bBlankPalette = FALSE;
|
|
|
|
if ( OIMIsNativeNP(lpDisplay) )
|
|
return (NULL);
|
|
|
|
|
|
// CHGetSecInfo( lpDisplay->Gen.hFilter, lpDisplay->Gen.wSection, &SecInfo );
|
|
SecInfo = *(CHLockSectionInfo(lpDisplay->Gen.hFilter, lpDisplay->Gen.wSection));
|
|
CHUnlockSectionInfo(lpDisplay->Gen.hFilter, lpDisplay->Gen.wSection);
|
|
|
|
hPalette = NULL;
|
|
|
|
if( SecInfo.Attr.Vector.Header.wImageFlags & SO_VECTORRGBCOLOR )
|
|
{
|
|
if ( bRgbTo256Ok && lpDisplay->wScreenColors == 256 )
|
|
{
|
|
bBlankPalette = TRUE;
|
|
wNumColors = 256;
|
|
}
|
|
else
|
|
wNumColors = 0;
|
|
}
|
|
else
|
|
{
|
|
wNumColors = (WORD) SecInfo.Attr.Vector.wPaletteSize;
|
|
}
|
|
|
|
if( wNumColors )
|
|
{
|
|
hMem = UTGlobalAlloc( sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * wNumColors );
|
|
lpPalette = (LPLOGPALETTE) UTGlobalLock(hMem);
|
|
|
|
lpPalette->palVersion = 0x0300;
|
|
lpPalette->palNumEntries = wNumColors;
|
|
|
|
pNewEntry = (LPPALETTEENTRY) &(lpPalette->palPalEntry);
|
|
|
|
if ( bBlankPalette )
|
|
{
|
|
/* init to all black, end with white */
|
|
for( i=0; i < wNumColors; i++ )
|
|
{
|
|
pNewEntry[i].peRed = 0;
|
|
pNewEntry[i].peGreen = 0;
|
|
pNewEntry[i].peBlue = 0;
|
|
pNewEntry[i].peFlags = PC_RESERVED; /* Will animate this entry later */
|
|
}
|
|
pNewEntry[0].peFlags = 0; /* force first black entry */
|
|
pNewEntry[wNumColors-1].peRed = 0xFF;
|
|
pNewEntry[wNumColors-1].peGreen = 0xFF;
|
|
pNewEntry[wNumColors-1].peBlue = 0xFF;
|
|
pNewEntry[wNumColors-1].peFlags = 0; /* white entry forced at end of palette for background use */
|
|
}
|
|
else
|
|
{
|
|
pSrcEntry = (RGBQUAD far *) UTGlobalLock( SecInfo.Attr.Vector.hPalette );
|
|
for( i=0; i < wNumColors; i++ )
|
|
{
|
|
pNewEntry[i].peRed = pSrcEntry[i].rgbRed;
|
|
pNewEntry[i].peGreen = pSrcEntry[i].rgbGreen;
|
|
pNewEntry[i].peBlue = pSrcEntry[i].rgbBlue;
|
|
pNewEntry[i].peFlags = PC_NOCOLLAPSE;
|
|
}
|
|
UTGlobalUnlock( SecInfo.Attr.Vector.hPalette );
|
|
}
|
|
|
|
hPalette = CreatePalette(lpPalette);
|
|
|
|
UTGlobalUnlock(hMem);
|
|
UTGlobalFree(hMem);
|
|
}
|
|
*lpNumColors = wNumColors;
|
|
|
|
return( hPalette );
|
|
}
|
|
|
|
BOOL VUAddColorToPalette(lpDisplay,hDC,hPal,iDst,pColor)
|
|
POIM_DISPLAY lpDisplay;
|
|
HDC hDC;
|
|
HPALETTE hPal;
|
|
SHORT iDst;
|
|
SOCOLORREF FAR *pColor;
|
|
{
|
|
PALETTEENTRY Entry;
|
|
Entry.peRed = (BYTE)(*pColor & 0x000000ff);
|
|
Entry.peGreen = (BYTE)((*pColor >> 8) & 0x000000ff);
|
|
Entry.peBlue = (BYTE)((*pColor >> 16) & 0x000000ff);
|
|
Entry.peFlags = PC_RESERVED;
|
|
AnimatePalette ( hPal, iDst, 1, &Entry );
|
|
return(1);
|
|
}
|
|
|
|
|
|
#define MAXMETAREAD 32768
|
|
|
|
|
|
VOID WinGetFontSizeInfo(hdc,pInfo)
|
|
HDC hdc;
|
|
POIMFONTSIZEINFO pInfo;
|
|
{
|
|
TEXTMETRIC tm;
|
|
|
|
GetTextMetrics ( hdc, &tm );
|
|
|
|
pInfo->ascent = (SHORT)tm.tmAscent;
|
|
pInfo->descent = (SHORT)tm.tmDescent;
|
|
pInfo->leading = (SHORT)tm.tmInternalLeading;
|
|
pInfo->height = (SHORT)tm.tmHeight;
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------------
|
|
The routines below handle playing the native vector file format directly.
|
|
MetaFile for Windows.
|
|
-------------------------------------------------------------------------*/
|
|
|
|
|
|
BOOL OIMIsNativeNP(lpDisplay)
|
|
POIM_DISPLAY lpDisplay;
|
|
{
|
|
|
|
if ( lpDisplay->Gen.wFileId == FI_WINDOWSMETA || lpDisplay->Gen.wFileId == FI_BINARYMETAFILE )
|
|
return(TRUE);
|
|
else
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
VOID OIMUnloadNativeNP(lpDisplay)
|
|
POIM_DISPLAY lpDisplay;
|
|
{
|
|
if ( lpDisplay->Image.hMF )
|
|
DeleteMetaFile ( lpDisplay->Image.hMF );
|
|
/* Appears the delete metafile resolves the free below
|
|
if (lpDisplay->Image.hMetaBits)
|
|
UTGlobalFree(lpDisplay->Image.hMetaBits);
|
|
*/
|
|
}
|
|
|
|
WORD OIMLoadNativeNP( lpDisplay )
|
|
POIM_DISPLAY lpDisplay;
|
|
{
|
|
HIOFILE hFile;
|
|
DWORD dwOffsetToMeta, dwSize;
|
|
LONG lCount;
|
|
PFILTER pFilter;
|
|
HFILTER hFilter;
|
|
DWORD dwRetCount;
|
|
IOERR IOErr;
|
|
/* Read in the metafile */
|
|
hFilter = lpDisplay->Gen.hFilter;
|
|
pFilter = (PFILTER) UTGlobalLock( hFilter );
|
|
if( pFilter->pWakeFunc != NULL )
|
|
pFilter->pWakeFunc(hFilter);
|
|
hFile = lpDisplay->Gen.hFile;
|
|
|
|
lpDisplay->wFlags |= OIMF_IMAGEPRESENT;
|
|
|
|
if ( lpDisplay->Image.hMF == NULL )
|
|
{
|
|
HPBYTE hpBuffer;
|
|
|
|
IOSeek ( hFile, IOSEEK_TOP, 0 );
|
|
if ( lpDisplay->Gen.wFileId == FI_WINDOWSMETA )
|
|
{
|
|
dwOffsetToMeta = 22;
|
|
IOErr = IORead ( hFile, (LPBYTE)&lpDisplay->Image.APMHeader, 22, &dwRetCount );
|
|
if ( (IOErr != IOERR_OK) || (dwRetCount != 22) )
|
|
goto lm0;
|
|
}
|
|
else
|
|
dwOffsetToMeta = 0;
|
|
|
|
IOSeek ( hFile, IOSEEK_TOP, dwOffsetToMeta );
|
|
IOErr = IORead ( hFile, (LPBYTE)&lpDisplay->Image.mfHeader, 18, &dwRetCount );
|
|
if ( (IOErr != IOERR_OK) || (dwRetCount != 18 ) )
|
|
goto lm0;
|
|
|
|
if ( (lpDisplay->Image.hMetaBits = UTGlobalAlloc(lpDisplay->Image.mfHeader.mtSize*2)) == NULL )
|
|
{
|
|
goto lm0;
|
|
}
|
|
|
|
hpBuffer = UTGlobalLock(lpDisplay->Image.hMetaBits);
|
|
dwSize = lpDisplay->Image.mfHeader.mtSize*2;
|
|
IOSeek ( hFile, IOSEEK_TOP, dwOffsetToMeta );
|
|
IOErr = IORead(hFile, (LPBYTE)hpBuffer, dwSize, &dwRetCount );
|
|
/*
|
|
| We have seen WMF files which include the size of the APM in the
|
|
| mtSize of the metafile header (believe Corel Draw creates this).
|
|
| We have seen others which have a size that is 4 too high for no
|
|
| apparent reason.
|
|
| A fixup is below.
|
|
*/
|
|
if ( dwRetCount < dwSize )
|
|
dwSize = dwRetCount;
|
|
if ( (IOErr != IOERR_OK) || (dwRetCount != dwSize ) )
|
|
goto lm1;
|
|
|
|
UTGlobalUnlock(lpDisplay->Image.hMetaBits);
|
|
|
|
if ( lpDisplay->Gen.wFileId == FI_BINARYMETAFILE )
|
|
{
|
|
/*
|
|
| Find the window origin and window extent and set the
|
|
| APM header structure accordingly.
|
|
*/
|
|
WORD wFoundOrigin, wFoundExtent;
|
|
SHORT nOrgX, nOrgY, nExtX, nExtY;
|
|
PMTRECORD pRecord;
|
|
wFoundOrigin = 0;
|
|
wFoundExtent = 0;
|
|
lpDisplay->Image.APMHeader.inch = 0x240;
|
|
lpDisplay->Image.APMHeader.bboxleft = 0;
|
|
lpDisplay->Image.APMHeader.bboxtop = 0;
|
|
lpDisplay->Image.APMHeader.bboxright = 1000;
|
|
lpDisplay->Image.APMHeader.bboxbottom = 1000;
|
|
hpBuffer = UTGlobalLock(lpDisplay->Image.hMetaBits);
|
|
hpBuffer += lpDisplay->Image.mfHeader.mtHeaderSize*2;
|
|
lCount = lpDisplay->Image.mfHeader.mtSize*2;
|
|
lCount -= lpDisplay->Image.mfHeader.mtHeaderSize*2;
|
|
while ( lCount > 0 )
|
|
{
|
|
pRecord = (PMTRECORD)hpBuffer;
|
|
if ( pRecord->rdFunction == 0x020b ) // SetWindowOrg
|
|
{
|
|
nOrgY = (SHORT)(pRecord->rdParam[0]);
|
|
nOrgX = (SHORT)(pRecord->rdParam[1]);
|
|
wFoundOrigin = TRUE;
|
|
}
|
|
if ( pRecord->rdFunction == 0x020c ) // SetWindowExt
|
|
{
|
|
nExtY = (SHORT)(pRecord->rdParam[0]);
|
|
nExtX = (SHORT)(pRecord->rdParam[1]);
|
|
wFoundExtent = TRUE;
|
|
}
|
|
hpBuffer += pRecord->rdSize * 2;
|
|
lCount -= pRecord->rdSize * 2;
|
|
if ( wFoundOrigin && wFoundExtent )
|
|
break;
|
|
}
|
|
if ( wFoundOrigin )
|
|
{
|
|
lpDisplay->Image.APMHeader.bboxleft = nOrgX;
|
|
lpDisplay->Image.APMHeader.bboxtop = nOrgY;
|
|
}
|
|
if ( wFoundExtent )
|
|
{
|
|
lpDisplay->Image.APMHeader.bboxright = nOrgX + nExtX;
|
|
lpDisplay->Image.APMHeader.bboxbottom = nOrgY + nExtY;
|
|
}
|
|
UTGlobalUnlock(lpDisplay->Image.hMetaBits);
|
|
|
|
}
|
|
lpDisplay->Image.bbox.left = lpDisplay->Image.APMHeader.bboxleft;
|
|
lpDisplay->Image.bbox.top = lpDisplay->Image.APMHeader.bboxtop;
|
|
lpDisplay->Image.bbox.right = lpDisplay->Image.APMHeader.bboxright;
|
|
lpDisplay->Image.bbox.bottom = lpDisplay->Image.APMHeader.bboxbottom;
|
|
lpDisplay->Image.wWidth = (WORD)(lpDisplay->Image.APMHeader.bboxright -
|
|
lpDisplay->Image.APMHeader.bboxleft);
|
|
lpDisplay->Image.wHeight = (WORD)(lpDisplay->Image.APMHeader.bboxbottom -
|
|
lpDisplay->Image.APMHeader.bboxtop);
|
|
lpDisplay->Image.wHDpi = lpDisplay->Image.APMHeader.inch;
|
|
lpDisplay->Image.wVDpi = lpDisplay->Image.APMHeader.inch;
|
|
lpDisplay->Image.XDirection = 1;
|
|
lpDisplay->Image.YDirection = 1;
|
|
#ifdef WIN32
|
|
{
|
|
LPBYTE lpBuf;
|
|
lpBuf = UTGlobalLock ( lpDisplay->Image.hMetaBits );
|
|
lpDisplay->Image.hMF = SetMetaFileBitsEx((UINT)dwSize,lpBuf);
|
|
UTGlobalUnlock ( lpDisplay->Image.hMetaBits );
|
|
if ( !(lpDisplay->Image.hMF ) )
|
|
goto lm1;
|
|
}
|
|
#else
|
|
if( ! (lpDisplay->Image.hMF = SetMetaFileBits ( lpDisplay->Image.hMetaBits) ) )
|
|
goto lm1;
|
|
#endif
|
|
|
|
}
|
|
lpDisplay->Image.BkgColor = RGB ( 0xff, 0xff, 0xff );
|
|
|
|
if( pFilter->pSleepFunc != NULL )
|
|
pFilter->pSleepFunc(hFilter);
|
|
UTGlobalUnlock( hFilter );
|
|
return TRUE;
|
|
|
|
lm1: UTGlobalFree ( lpDisplay->Image.hMetaBits );
|
|
lpDisplay->Image.hMetaBits = NULL;
|
|
lm0:
|
|
lpDisplay->Image.hMF = NULL;
|
|
if( pFilter->pSleepFunc != NULL )
|
|
pFilter->pSleepFunc(hFilter);
|
|
UTGlobalUnlock( hFilter );
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
VOID OIMPlayNativeNP (hDC, lpDisplay)
|
|
HDC hDC;
|
|
POIM_DISPLAY lpDisplay;
|
|
{
|
|
if ( lpDisplay->Image.hMF )
|
|
PlayMetaFile ( hDC, lpDisplay->Image.hMF );
|
|
}
|
|
|
|
|
|
|
|
#ifdef SCCFEATURE_DRAWTORECT
|
|
WORD OIMInitDrawToRect(lpDisplay,lpDrawInfo)
|
|
POIM_DISPLAY lpDisplay;
|
|
PSCCDDRAWTORECT lpDrawInfo;
|
|
{
|
|
BOOL bNew;
|
|
if ( lpDrawInfo->bLoadDoc )
|
|
{
|
|
OIMInitMetaBasics ( lpDisplay );
|
|
lpDisplay->bDisplayOnReadAhead = FALSE;
|
|
|
|
/* A single handle readahead will use the section info to setup image info */
|
|
CHReadAhead( lpDisplay->Gen.hFilter, &lpDisplay->Gen.wSection, &bNew );
|
|
OIMHandleReadAhead( lpDisplay );
|
|
/* If metafile then directly load it into memory */
|
|
if ( OIMIsNativeNP(lpDisplay) )
|
|
OIMLoadNativeNP ( lpDisplay );
|
|
|
|
OIMSetScaleValues(lpDisplay);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
WORD OIMMapDrawToRect(lpDisplay,lpDrawInfo)
|
|
POIM_DISPLAY lpDisplay;
|
|
PSCCDDRAWTORECT lpDrawInfo;
|
|
{
|
|
if (!lpDrawInfo->bWholeDoc)
|
|
{
|
|
HDC hdc;
|
|
SOPOINT Pt[2];
|
|
hdc = VUGetScreenDC(lpDisplay);
|
|
OISetupScaledDraw( hdc, lpDisplay );
|
|
Pt[0].x = lpDisplay->rcSelect.left+lpDisplay->nWindowXOffset-lpDisplay->ptWinOrg.x;
|
|
Pt[0].y = lpDisplay->rcSelect.top+lpDisplay->nWindowYOffset-lpDisplay->ptWinOrg.y;
|
|
Pt[1].x = lpDisplay->rcSelect.right+lpDisplay->nWindowXOffset-lpDisplay->ptWinOrg.x;
|
|
Pt[1].y = lpDisplay->rcSelect.bottom+lpDisplay->nWindowYOffset-lpDisplay->ptWinOrg.y;
|
|
VUDPtoLP(hdc,Pt,2);
|
|
VUReleaseScreenDC(lpDisplay,hdc);
|
|
lpDrawInfo->lDELeft = Pt[0].x;
|
|
lpDrawInfo->lDETop = Pt[0].y;
|
|
lpDrawInfo->lDERight = Pt[1].x;
|
|
lpDrawInfo->lDEBottom = Pt[1].y;
|
|
}
|
|
else
|
|
{
|
|
lpDrawInfo->lDELeft = lpDisplay->Image.bbox.left;
|
|
lpDrawInfo->lDETop = lpDisplay->Image.bbox.top;
|
|
lpDrawInfo->lDERight = lpDisplay->Image.bbox.right;
|
|
lpDrawInfo->lDEBottom = lpDisplay->Image.bbox.bottom;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
WORD OIMDrawToRect(lpDisplay,lpDrawInfo)
|
|
POIM_DISPLAY lpDisplay;
|
|
PSCCDDRAWTORECT lpDrawInfo;
|
|
{
|
|
HRGN hClipRgn;
|
|
HDC hdc;
|
|
WORD wPlayState;
|
|
hdc = VUGetDC(lpDisplay);
|
|
if ( lpDisplay->Image.hPalette == NULL )
|
|
lpDisplay->Image.hPalette = VUSetupPalette( hdc, lpDisplay, &lpDisplay->Image.wPaletteSize, TRUE );
|
|
|
|
if( lpDisplay->Image.hPalette != NULL && hdc )
|
|
{
|
|
VUSelectPalette( hdc, lpDisplay->Image.hPalette, FALSE );
|
|
VURealizePalette( lpDisplay, hdc );
|
|
}
|
|
hClipRgn = VUGetClipRgn(hdc);
|
|
switch ( lpDisplay->Gen.wOutputType )
|
|
{
|
|
case SCCD_SCREEN:
|
|
wPlayState = OIMF_PLAYTOSCREEN;
|
|
break;
|
|
|
|
case SCCD_META:
|
|
wPlayState = OIMF_PLAYTOMETA;
|
|
break;
|
|
|
|
case SCCD_PRINTER:
|
|
default:
|
|
wPlayState = OIMF_PLAYTOPRINTER;
|
|
break;
|
|
}
|
|
|
|
OIMPlayFile ( hdc, hClipRgn, lpDisplay, wPlayState );
|
|
|
|
if (hClipRgn)
|
|
VUDeleteRgn ( hClipRgn );
|
|
|
|
VUReleaseDC(lpDisplay,hdc);
|
|
if ( lpDrawInfo->bLoadDoc )
|
|
{
|
|
lpDrawInfo->hPalette = lpDisplay->Image.hPalette;
|
|
OIMDeInitDisplay(lpDisplay);
|
|
}
|
|
else
|
|
{
|
|
// May need to duplicate the palette in this case
|
|
lpDrawInfo->hPalette = NULL;
|
|
}
|
|
return(0);
|
|
}
|
|
#endif // SCCFEATURE_DRAWTORECT
|
|
|
|
VOID OIMSaveStateNP ( lpDisplay )
|
|
POIM_DISPLAY lpDisplay;
|
|
{
|
|
}
|
|
|
|
VOID OIMRestoreStateNP ( lpDisplay )
|
|
POIM_DISPLAY lpDisplay;
|
|
{
|
|
}
|
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------
|
|
The routines below provide a 16-bit GDI unit to 32-bit GDI unit layer
|
|
to the routines which use pointers to int or pointers to rects. Long
|
|
term we need to "virtualize" the GDI basic unit size. That will take a
|
|
little bit more work.
|
|
---------------------------------------------------------------------*/
|
|
|
|
|
|
BOOL Win32Fixup ( lpFix, lpInt, nCount )
|
|
PFIXUP lpFix;
|
|
LPSHORT lpInt;
|
|
SHORT nCount;
|
|
{
|
|
SHORT i;
|
|
lpFix->hData = UTGlobalAlloc( sizeof(int)*nCount );
|
|
lpFix->pInt = NULL;
|
|
if ( lpFix->hData )
|
|
{
|
|
lpFix->pInt = UTGlobalLock(lpFix->hData);
|
|
for (i=0; i<nCount; i++ )
|
|
lpFix->pInt[i] =lpInt[i];
|
|
return(1);
|
|
}
|
|
else
|
|
return(0);
|
|
}
|
|
|
|
BOOL Win32FreeFixup ( lpFix )
|
|
PFIXUP lpFix;
|
|
{
|
|
UTGlobalUnlock(lpFix->hData);
|
|
UTGlobalFree(lpFix->hData);
|
|
return(1);
|
|
}
|
|
|
|
BOOL Win32LPtoDP(hDC,lpPt,n)
|
|
HDC hDC;
|
|
PSOPOINT lpPt;
|
|
SHORT n;
|
|
{
|
|
FIXUP Fix;
|
|
if(Win32Fixup(&Fix,(LPSHORT)lpPt,(SHORT)(n*2)))
|
|
{
|
|
LPSHORT lpShort;
|
|
SHORT i;
|
|
LPtoDP(hDC,(LPPOINT)Fix.pInt,n);
|
|
lpShort = (LPSHORT)lpPt;
|
|
for (i=0; i < n*2; i++)
|
|
lpShort[i] = Fix.pInt[i];
|
|
Win32FreeFixup(&Fix);
|
|
return(1);
|
|
}
|
|
else
|
|
return(0);
|
|
}
|
|
|
|
BOOL Win32DPtoLP(hDC,lpPt,n)
|
|
HDC hDC;
|
|
PSOPOINT lpPt;
|
|
SHORT n;
|
|
{
|
|
FIXUP Fix;
|
|
if(Win32Fixup(&Fix,(LPSHORT)lpPt,(SHORT)(n*2)))
|
|
{
|
|
LPSHORT lpShort;
|
|
SHORT i;
|
|
DPtoLP(hDC,(LPPOINT)Fix.pInt,n);
|
|
lpShort = (LPSHORT)lpPt;
|
|
for (i=0; i < n*2; i++)
|
|
lpShort[i] = Fix.pInt[i];
|
|
Win32FreeFixup(&Fix);
|
|
return(1);
|
|
}
|
|
else
|
|
return(0);
|
|
}
|
|
|
|
|
|
BOOL Win32RectInRegion(hRgn,pRect)
|
|
HRGN hRgn;
|
|
PSORECT pRect;
|
|
{
|
|
BOOL Ret;
|
|
FIXUP Fix;
|
|
if(Win32Fixup(&Fix,(LPSHORT)pRect,4))
|
|
{
|
|
Ret = RectInRegion(hRgn,(LPRECT)Fix.pInt);
|
|
Win32FreeFixup(&Fix);
|
|
}
|
|
else
|
|
Ret=0;
|
|
return(Ret);
|
|
}
|
|
|
|
BOOL Win32Polyline(hDC,lpPoint,nPoints)
|
|
HDC hDC;
|
|
PSOPOINT lpPoint;
|
|
SHORT nPoints;
|
|
{
|
|
BOOL Ret;
|
|
FIXUP Fix;
|
|
if(Win32Fixup(&Fix,(LPSHORT)lpPoint,(SHORT)(nPoints*2)))
|
|
{
|
|
Ret = Polyline(hDC,(LPPOINT)Fix.pInt,nPoints);
|
|
Win32FreeFixup(&Fix);
|
|
}
|
|
else
|
|
Ret=0;
|
|
return(Ret);
|
|
}
|
|
|
|
Win32Polygon(hDC,lpPoint,nPoints)
|
|
HDC hDC;
|
|
PSOPOINT lpPoint;
|
|
SHORT nPoints;
|
|
{
|
|
BOOL Ret;
|
|
FIXUP Fix;
|
|
if(Win32Fixup(&Fix,(LPSHORT)lpPoint,(SHORT)(nPoints*2)))
|
|
{
|
|
Ret = Polygon(hDC,(LPPOINT)Fix.pInt,nPoints);
|
|
Win32FreeFixup(&Fix);
|
|
}
|
|
else
|
|
Ret=0;
|
|
return(Ret);
|
|
}
|
|
|
|
|
|
BOOL Win32PolyPolygon(hDC,lpPolyPoints,lpPolyCounts,nCount)
|
|
HDC hDC;
|
|
PSOPOINT lpPolyPoints;
|
|
LPSHORT lpPolyCounts;
|
|
SHORT nCount;
|
|
{
|
|
BOOL Ret;
|
|
FIXUP FixCounts, FixPoints;
|
|
|
|
if(Win32Fixup(&FixCounts,lpPolyCounts,nCount))
|
|
{
|
|
SHORT i, nPoints;
|
|
nPoints = 0;
|
|
for (i=0; i < nCount; i++ )
|
|
nPoints += lpPolyCounts[i];
|
|
if(Win32Fixup(&FixPoints,(LPSHORT)lpPolyPoints,(SHORT)(nPoints*2)))
|
|
{
|
|
Ret = PolyPolygon(hDC,(LPPOINT)FixPoints.pInt,FixCounts.pInt,nCount);
|
|
Win32FreeFixup(&FixPoints);
|
|
}
|
|
else
|
|
Ret = 0;
|
|
Win32FreeFixup(&FixCounts);
|
|
}
|
|
else
|
|
Ret = 0;
|
|
return(Ret);
|
|
}
|
|
|
|
HRGN Win32CreatePolygonRgn(lpPoints,nPoints,nPolyFillMode)
|
|
PSOPOINT lpPoints;
|
|
SHORT nPoints;
|
|
SHORT nPolyFillMode;
|
|
{
|
|
HRGN Ret;
|
|
FIXUP Fix;
|
|
if(Win32Fixup(&Fix,(LPSHORT)lpPoints,(SHORT)(nPoints*2)))
|
|
{
|
|
Ret = CreatePolygonRgn((LPPOINT)Fix.pInt,nPoints,nPolyFillMode);
|
|
Win32FreeFixup(&Fix);
|
|
}
|
|
else
|
|
Ret=0;
|
|
return(Ret);
|
|
}
|
|
|
|
HRGN Win32CreatePolyPolygonRgn(lpPolyPoints,lpPolyCounts,nCount,nPolyFillMode)
|
|
PSOPOINT lpPolyPoints;
|
|
LPSHORT lpPolyCounts;
|
|
SHORT nCount;
|
|
SHORT nPolyFillMode;
|
|
{
|
|
HRGN Ret;
|
|
FIXUP FixCounts, FixPoints;
|
|
|
|
if(Win32Fixup(&FixCounts,lpPolyCounts,nCount))
|
|
{
|
|
SHORT i, nPoints;
|
|
nPoints = 0;
|
|
for (i=0; i < nCount; i++ )
|
|
nPoints += lpPolyCounts[i];
|
|
if(Win32Fixup(&FixPoints,(LPSHORT)lpPolyPoints,(SHORT)(nPoints*2)))
|
|
{
|
|
Ret = CreatePolyPolygonRgn((LPPOINT)FixPoints.pInt,(LPINT)FixCounts.pInt,nCount,nPolyFillMode);
|
|
Win32FreeFixup(&FixPoints);
|
|
}
|
|
else
|
|
Ret = 0;
|
|
Win32FreeFixup(&FixCounts);
|
|
}
|
|
else
|
|
Ret = 0;
|
|
return(Ret);
|
|
}
|
|
|
|
BOOL Win32GetCursorPos(lpPt)
|
|
PSOPOINT lpPt;
|
|
{
|
|
POINT Pt;
|
|
GetCursorPos(&Pt);
|
|
lpPt->x = (SHORT)Pt.x;
|
|
lpPt->y = (SHORT)Pt.y;
|
|
return(1);
|
|
}
|
|
|
|
BOOL Win32DrawText(hDC,lpStr,nCount,lpRect,wFormat)
|
|
HDC hDC;
|
|
LPBYTE lpStr;
|
|
SHORT nCount;
|
|
PSORECT lpRect;
|
|
WORD wFormat;
|
|
{
|
|
RECT rc;
|
|
rc.top = lpRect->top;
|
|
rc.bottom = lpRect->bottom;
|
|
rc.left = lpRect->left;
|
|
rc.right = lpRect->right;
|
|
return((BOOL)DrawText(hDC,lpStr,nCount, &rc, wFormat));
|
|
}
|
|
|
|
DWORD Win32GetTextWidth(hdc,lpText,Size)
|
|
HDC hdc;
|
|
LPSTR lpText;
|
|
SHORT Size;
|
|
{
|
|
SIZE sDim;
|
|
GetTextExtentPoint ( hdc, lpText, Size, &sDim );
|
|
return((DWORD)sDim.cx);
|
|
}
|
|
|
|
|
|
BOOL Win32ScreenToClient(hWnd,lpPt)
|
|
HWND hWnd;
|
|
PSOPOINT lpPt;
|
|
{
|
|
POINT Pt;
|
|
ScreenToClient(hWnd,&Pt);
|
|
lpPt->x = (SHORT)Pt.x;
|
|
lpPt->y = (SHORT)Pt.y;
|
|
return(1);
|
|
}
|
|
|