archive
/
windows-nt-4.0
mirror of https://github.com/lianthony/NT4.0
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Windows NT 4.0 source code leak
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.
2 Commits
1 Branch
0 Tags
184 MiB
 
 
 
 
 
 
Tree: b4a8d373d8
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b4a8d373d8'
${ noResults }
windows-nt-4.0/private/ntos/w32/ntgdi/printers/rasprint/tools/ntres/ntgpcedt.c

2611 lines
56 KiB
Raw Blame History

/*++
Copyright (c) 1990-1991 Microsoft Corporation
Module Name:
NTGPCEDT.C
Abstract:
This module contains the RASDD's NT.GPC generation functions
Author:
23-Jun-1993 Wed 14:01:43 Created -by- Daniel Chou (danielc)
[Environment:]
GDI Printer Mini Driver Tools
[Notes:]
Revision History:
--*/
#include <stddef.h>
#include <windows.h>
#include <winddi.h>
#include <commdlg.h>
#include <ntres.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <ntgpcedt.h>
#if DBG
extern
UINT
cdecl
DbgPrint(
LPSTR pStr,
...
);
#define ARG(x) ,(x)
#define ARGB(x) ,(BYTE)(x)
#define ARGC(x) ,(CHAR)(x)
#define ARGW(x) ,(WORD)(x)
#define ARGS(x) ,(SHORT)(x)
#define ARGU(x) ,(UINT)(x)
#define ARGI(x) ,(INT)(x)
#define ARGDW(x) ,(DWORD)(x)
#define ARGL(x) ,(LONG)(x)
#define ARGP(x) ,(LPVOID)(x)
#define DBGP(y) DbgPrint(y)
#else
#define ARG(x)
#define ARGB(x)
#define ARGC(x)
#define ARGW(x)
#define ARGS(x)
#define ARGU(x)
#define ARGI(x)
#define ARGDW(x)
#define ARGL(x)
#define ARGP(x)
#define DBGP(y)
#endif
#define CIE_x_MIN 10
#define CIE_x_MAX 8000
#define CIE_y_MIN 10
#define CIE_y_MAX 8500
#define CIE_Y_MIN 100
#define CIE_Y_MAX 20000
#define CIE_W_MIN 2500
#define CIE_W_STD 10000
#define CIE_W_MAX 40000
#define MIN_DEV_GAMMA 1000
#define MAX_DEV_GAMMA 65000
#define STD_ADD_DEV_GAMMA 20000
#define STD_SUB_DEV_GAMMA 10000
#define MIN_DYE_MIX 0
#define MAX_DYE_MIX 9000
#define DEV_PEL_MIN 0
#define DEV_PEL_MAX 12000
typedef NT_RES FAR *PNT_RES;
typedef struct _MODELRES {
NR_COLORINFO ciRes;
NR_HT htRes;
} MODELRES, FAR *PMODELRES;
COLORREF DlgLoClr = RGB(0x00, 0x00, 0x00);
COLORREF DlgHiClr = RGB(0x80, 0x00, 0x00);
WORD SizeNTGPC = 0;
INT ModelIdx = 0;
INT TotalModels = 0;
HFILE hFileNTGPC = HFILE_ERROR;
BOOL UpdateNTGPC = FALSE;
PNT_RES pOrgNTRes = NULL;
PNT_RES pCurNTRes = NULL;
PMODELRES pCurMR = NULL;
PMODELRES pOrgMR = NULL;
MODELRES MRCopyBuf;
#define GET_PMR(pNTRes, iModel) \
(PMODELRES)((LPBYTE)pNTRes + pNTRes->awOffset[pNTRes->cwEntry * iModel]);
MODELRES DefModelRes = {
{
sizeof(NR_COLORINFO),
NR_CI_VERSION,
{
{ 6810, 3050, 2897 }, // xr, yr, Yr
{ 2260, 6550, 6056 }, // xg, yg, Yg
{ 1810, 500, 1047 }, // xb, yb, Yb
{ 2000, 2450, 6912 }, // xc, yc, Yc
{ 5210, 2100, 3732 }, // xm, ym, Ym
{ 4750, 5100, 9120 }, // xy, yy, Yy
{ 3324, 3474, 10000 }, // xw, yw, Yw
STD_SUB_DEV_GAMMA, // R gamma
STD_SUB_DEV_GAMMA, // G gamma
STD_SUB_DEV_GAMMA, // B gamma
1422, 952, // M/C, Y/C
787, 495, // C/M, Y/M
324, 248 // C/Y, M/Y
}
},
{
sizeof(NR_HT),
NR_HT_VERSION,
0,
HT_PATSIZE_6x6_M
}
};
CHAR szAppName[] = "NTGPCEDT";
CHAR szAppAccel[] = "AccelTable";
CHAR szAppIcon[] = "NTResIcon";
CHAR szDefNTGPC[] = "nt.gpc";
CHAR szNTGPCFile[64] = "nt.gpc";
CHAR szRCFile[64] = "*.rc";
BYTE DoubleQuote[] = { 0x22, 0x00 };
BYTE SepInLine[] = " ,\t\n";
BYTE LineEnd[] = { 0x0d, 0x0a, 0x00 };
HWND hWndApp = NULL;
HINSTANCE hInstApp = NULL;
HICON hIconApp = NULL;
LPBYTE pHTPatSize[] = {
"HT_PATSIZE_2x2",
"HT_PATSIZE_2x2_M",
"HT_PATSIZE_4x4",
"HT_PATSIZE_4x4_M",
"HT_PATSIZE_6x6",
"HT_PATSIZE_6x6_M",
"HT_PATSIZE_8x8",
"HT_PATSIZE_8x8_M",
"HT_PATSIZE_10x10",
"HT_PATSIZE_10x10_M",
"HT_PATSIZE_12x12",
"HT_PATSIZE_12x12_M",
"HT_PATSIZE_14x14",
"HT_PATSIZE_14x14_M",
"HT_PATSIZE_16x16",
"HT_PATSIZE_16x16_M",
NULL
};
WORD DisableGroup[] = {
IDD_CIE_R_PUSH,
IDD_CIE_G_PUSH,
IDD_CIE_B_PUSH,
IDD_CIE_C_PUSH,
IDD_CIE_M_PUSH,
IDD_CIE_Y_PUSH,
IDD_CIE_W_PUSH,
IDD_8BIT_HALFTONE,
IDD_GAMMA_PUSH,
IDD_HTPAT_SIZE_PUSH,
IDD_PELSIZE_PUSH,
IDD_DYE_C_PUSH,
IDD_DYE_M_PUSH,
IDD_DYE_Y_PUSH,
IDD_SAVE,
IDD_DEFAULT,
IDD_REVERT,
IDD_COPY,
IDD_PASTE,
0,
};
typedef struct _S3FORMAT {
BYTE Str[10];
WORD Div;
} S3FORMAT;
S3FORMAT S3Format[] = {
{ "%u.%04u", 10000 },
{ "%u.%02u", 100 },
{ "", 0 }
};
typedef struct _SCROLL3 {
LPBYTE pPrefix;
LDECI4 *pUpdate;
LDECI4 *pDefault;
LDECI4 *pOrg;
WORD Min[3];
WORD Max[3];
BYTE Format[3];
BYTE Step[3];
WORD Cur[3];
HWND hPush;
} SCROLL3, *PSCROLL3;
SCROLL3 PelSize_S3 = {
NULL, NULL, NULL, NULL,
{ 0, 0, 0 },
{ 12000, 12000, 12000 },
{ 2, 2, 2 },
{ 5, 0xff, 0xff },
{ 0, 0, 0 }
};
SCROLL3 CIEDye_S3 = {
NULL, NULL, NULL, NULL,
{ MIN_DYE_MIX, MIN_DYE_MIX, MIN_DYE_MIX },
{ MAX_DYE_MIX, MAX_DYE_MIX, MAX_DYE_MIX },
{ 1, 1, 1 },
{ 25, 25, 25 },
{ 0, 0, 0 }
};
SCROLL3 CIEGamma_S3 = {
NULL, NULL, NULL, NULL,
{ MIN_DEV_GAMMA, MIN_DEV_GAMMA, MIN_DEV_GAMMA },
{ MAX_DEV_GAMMA, MAX_DEV_GAMMA, MAX_DEV_GAMMA },
{ 0, 0, 0 },
{ 100, 100, 100 },
{ 0, 0, 0 }
};
SCROLL3 CIExyY_S3 = {
NULL, NULL, NULL, NULL,
{ CIE_x_MIN, CIE_y_MIN, CIE_Y_MIN },
{ CIE_x_MAX, CIE_y_MAX, CIE_Y_MAX },
{ 0, 0, 1 },
{ 50, 50, 50 },
{ 0, 0, 0 }
};
LPBYTE pDyePrefix[3];
LPBYTE pCIExyYPrefix[7];
BYTE ResStrData[1024];
LPBYTE pResStr[IDS_STR_GROUP_LAST - IDS_STR_GROUP_FIRST + 1];
#define PRES_STR(x) pResStr[x## - IDS_STR_GROUP_FIRST]
UINT
LoadStringFromRes(
HINSTANCE hInst
)
{
UINT pIdx;
UINT UseIdx;
UINT StrID;
for (pIdx = UseIdx = 0, StrID = IDS_STR_GROUP_FIRST;
StrID <= IDS_STR_GROUP_LAST;
StrID++, pIdx++) {
pResStr[pIdx] = &ResStrData[UseIdx];
UseIdx += (LoadString(hInstApp,
StrID,
&ResStrData[UseIdx],
sizeof(ResStrData) - UseIdx) + 1);
// DBGP("\n%2u [%3u] = %s"
// ARGU(pIdx) ARGU(strlen(pResStr[pIdx])) ARGP(pResStr[pIdx]));
}
// DBGP("\n\nTotal BYTE used for RES STR is %u bytes\n" ARGU(UseIdx));
pCIExyYPrefix[0] = PRES_STR(IDS_RED);
pCIExyYPrefix[1] = PRES_STR(IDS_GREEN);
pCIExyYPrefix[2] = PRES_STR(IDS_BLUE);
pDyePrefix[0] =
pCIExyYPrefix[3] = PRES_STR(IDS_CYAN);
pDyePrefix[1] =
pCIExyYPrefix[4] = PRES_STR(IDS_MAGENTA);
pDyePrefix[2] =
pCIExyYPrefix[5] = PRES_STR(IDS_YELLOW);
pCIExyYPrefix[6] = PRES_STR(IDS_WHITE);
return(pIdx);
}
BOOL
GetNewRCFileName(
HWND hDlg
)
/*++
Routine Description:
This functions pop-up dialog box and ask a new dib, if file exist and
user select ok then it create a new dib from the file.
Arguments:
pHTClrAdjParam
Return Value:
HANDLE to the DIB, NULL if not sucessful
Author:
02-Sep-1992 Wed 12:53:21 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
OPENFILENAME ofn;
UINT i;
BYTE Buf[350];
i = strlen(strcpy(Buf, szRCFile)) + 1;
if (!GetDlgItemText(hDlg, IDD_RC_DIR, &Buf[i], sizeof(Buf) - i)) {
GetCurrentDirectory(sizeof(Buf) - i, &Buf[i]);
}
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hDlg;
ofn.hInstance = hInstApp;
ofn.lpstrFilter = "*.rc\0*.rc\0All files (*.*)\0*.*\0\0";
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 0;
ofn.lpstrFile = Buf;
ofn.nMaxFile = sizeof(Buf);
ofn.lpstrFileTitle = NULL;
ofn.lpstrInitialDir = &Buf[i];
ofn.lpstrTitle = PRES_STR(IDS_OPEN_TITLE);
ofn.Flags = OFN_PATHMUSTEXIST |
OFN_FILEMUSTEXIST |
OFN_HIDEREADONLY |
OFN_SHOWHELP;
ofn.nFileOffset = 0;
ofn.nFileExtension = 0;
ofn.lpstrDefExt = "RC";
ofn.lCustData = 0;
ofn.lpfnHook = NULL;
ofn.lpTemplateName = NULL;
if (GetOpenFileName(&ofn)) {
strcpy(szRCFile, &Buf[ofn.nFileOffset]);
Buf[ofn.nFileOffset] = 0;
SetDlgItemText(hDlg, IDD_RC_DIR, Buf);
return(TRUE);
} else {
return(FALSE);
}
}
typedef struct _FILEIO {
HFILE hFile;
WORD CurIdx;
WORD EndIdx;
BYTE Buf[4096];
} FILEIO, FAR *PFILEIO;
LPBYTE
GetToken(
PFILEIO pFileIO,
LPBYTE pTokenSep
)
{
LPBYTE pTokenChk;
INT TokenBeg;
INT TokenEnd;
WORD CurIdx;
WORD EndIdx;
BYTE PrevCh;
BYTE ch;
TokenBeg =
TokenEnd = -1;
CurIdx = pFileIO->CurIdx;
EndIdx = pFileIO->EndIdx;
ch = 0;
while (TokenBeg < 0) {
if (CurIdx < EndIdx) {
PrevCh = ch;
ch = pFileIO->Buf[CurIdx];
if ((ch > ' ') && (ch != ',')) {
TokenBeg = CurIdx;
}
++CurIdx;
} else {
if ((EndIdx = _lread(pFileIO->hFile,
pFileIO->Buf,
sizeof(pFileIO->Buf))) == 0) {
return(NULL);
}
// DBGP("\n** Read &Buf[0] of %ld bytes" ARGL(EndIdx));
CurIdx = 0;
}
}
ch = 0;
while (TokenEnd < 0) {
if (CurIdx < EndIdx) {
PrevCh = ch;
ch = pFileIO->Buf[CurIdx];
if (pTokenChk = pTokenSep) {
while (*pTokenChk) {
if ((ch == *pTokenChk++) &&
(PrevCh != 0x5c)) {
TokenEnd = CurIdx;
break;
}
}
} else {
if ((ch <= ' ') || (ch == ',')) {
TokenEnd = CurIdx;
}
}
++CurIdx;
} else {
if (TokenBeg) {
CopyMemory(&(pFileIO->Buf[0]),
&(pFileIO->Buf[TokenBeg]),
EndIdx -= TokenBeg);
// DBGP("\n** MOVE from &Buf[%ld] to &Buf[0] of %ld bytes"
// ARGL(TokenBeg) ARGL(EndIdx));
TokenBeg = 0;
}
CurIdx = EndIdx;
if ((EndIdx = _lread(pFileIO->hFile,
&(pFileIO->Buf[CurIdx]),
sizeof(pFileIO->Buf) - CurIdx)) == 0) {
TokenEnd = CurIdx;
}
// DBGP("\n** Read &Buf[%ld] of %ld bytes" ARGL(CurIdx) ARGL(EndIdx));
EndIdx += CurIdx;
}
}
pFileIO->CurIdx = CurIdx;
pFileIO->EndIdx = EndIdx;
pFileIO->Buf[TokenEnd] = 0;
// DBGP("\nToken: %4u-%4u = %s"
// ARGU(TokenBeg) ARGU(TokenEnd)
// ARGP(&(pFileIO->Buf[TokenBeg])));
return((LPBYTE)&(pFileIO->Buf[TokenBeg]));
}
VOID
ShowTitle(
HWND hDlg
)
{
BYTE Buf[280];
BOOL Update;
if (hFileNTGPC == HFILE_ERROR) {
Update = FALSE;
} else {
Update = UpdateNTGPC;
}
sprintf(Buf, "%s - %s, %s%c (%u %s%s",
PRES_STR(IDS_APP_TITLE), szRCFile, szNTGPCFile,
(Update) ? '*' : ' ',
TotalModels, PRES_STR(IDS_MODEL_TITLE),
(TotalModels > 1) ? "s)" : ")" );
SetWindowText(hDlg, Buf);
EnableWindow(GetDlgItem(hDlg, IDD_SAVE), Update);
}
BOOL
ValidateModelRes(
PMODELRES pMR
)
{
UINT Err = 0;
if ((pMR->ciRes.cjThis != sizeof(NR_COLORINFO)) ||
(pMR->ciRes.wVersion != NR_CI_VERSION)) {
DBGP("\nError: NR_COLORINFO: cjThis=%u, Version=%u"
ARGU(pMR->ciRes.cjThis) ARGU(pMR->ciRes.wVersion));
pMR->ciRes = DefModelRes.ciRes;
++Err;
} else {
//
// Validate ColorInfo
//
CIECHROMA FAR *pCIEChroma;
CIECHROMA FAR *pSTDChroma;
LDECI4 *pLDECI4;
LDECI4 *pStdLDECI4;
UINT Loop;
Loop = 7;
pCIEChroma = &(pMR->ciRes.ci.Red);
pSTDChroma = &(DefModelRes.ciRes.ci.Red);
while (Loop--) {
if ((pCIEChroma->x < (LDECI4)CIE_x_MIN) ||
(pCIEChroma->x > (LDECI4)CIE_x_MAX) ||
(pCIEChroma->y < (LDECI4)CIE_y_MIN) ||
(pCIEChroma->y > (LDECI4)CIE_y_MAX) ||
((Loop) &&
((pCIEChroma->Y < (LDECI4)CIE_Y_MIN) ||
(pCIEChroma->Y > (LDECI4)CIE_Y_MAX))) ||
((!Loop) &&
((pCIEChroma->Y < (LDECI4)CIE_W_MIN) ||
(pCIEChroma->Y > (LDECI4)CIE_W_MAX)))) {
*pCIEChroma = *pSTDChroma;
}
++pCIEChroma;
++pSTDChroma;
}
//
// Checking Gamma Information
//
pLDECI4 = (LDECI4 FAR *)&(pMR->ciRes.ci.RedGamma);
pStdLDECI4 = (LDECI4 FAR *)&(DefModelRes.ciRes.ci.RedGamma);
Loop = 3;
while (Loop--) {
if ((*pLDECI4 < (LDECI4)MIN_DEV_GAMMA) ||
(*pLDECI4 > (LDECI4)MAX_DEV_GAMMA)) {
*pLDECI4 = *pStdLDECI4;
++Err;
}
++pLDECI4;
++pStdLDECI4;
}
//
// Validate Dye Mix
//
pLDECI4 = (LDECI4 FAR *)&(pMR->ciRes.ci.MagentaInCyanDye);
pStdLDECI4 = (LDECI4 FAR *)&(DefModelRes.ciRes.ci.MagentaInCyanDye);
Loop = 6;
while (Loop--) {
if ((*pLDECI4 < (LDECI4)MIN_DYE_MIX) ||
(*pLDECI4 > (LDECI4)MAX_DYE_MIX)) {
*pLDECI4 = *pStdLDECI4;
++Err;
}
++pLDECI4;
++pStdLDECI4;
}
}
if ((pMR->htRes.cjThis != sizeof(NR_HT)) ||
(pMR->htRes.wVersion != NR_HT_VERSION)) {
DBGP("\nError: NR_HT: cjThis=%u, Version=%u"
ARGU(pMR->htRes.cjThis) ARGU(pMR->htRes.wVersion));
pMR->htRes = DefModelRes.htRes;
++Err;
} else {
if (pMR->htRes.ulPatternSize > HT_PATSIZE_16x16_M) {
pMR->htRes.ulPatternSize = HT_PATSIZE_4x4_M;
++Err;
}
}
if (Err) {
DBGP("\nValidateModelRes(%u): Error Count = %u"
ARGU(((LPBYTE)pMR -
(LPBYTE)((LPBYTE)pOrgNTRes + pOrgNTRes->cjThis)) /
sizeof(MODELRES))
ARGU(Err));
}
return(Err == 0);
}
BOOL
GetNTGPCData(
LONG Offset,
LPBYTE pMem,
DWORD Size
)
{
UINT cRead;
if (hFileNTGPC == HFILE_ERROR) {
DBGP("\nhFileNTGPC = HFILE_ERROR");
return(FALSE);
}
if (Offset < (sizeof(NT_RES) - sizeof(pOrgNTRes->awOffset))) {
DBGP("\nError: No NTGPC data at offset %ld" ARGDW(Offset));
return(FALSE);
}
if (_llseek(hFileNTGPC, Offset, 0) != Offset) {
DBGP("\nSeek(%ld) FAILED!" ARGDW(Offset));
return(FALSE);
}
if ((cRead = (UINT)_lread(hFileNTGPC, (LPVOID)pMem, (UINT)Size)) != Size) {
DBGP("\nFAILD Read(%ld) = %ld" ARGDW(Size) ARGL(cRead));
return(FALSE);
}
return(TRUE);
}
BOOL
InitNTGPC(
HWND hDlg
)
{
WORD *pw;
PMODELRES pMR;
INT i;
WORD SizeA;
WORD SizeB;
WORD cModels;
WORD cEntry;
WORD wOffset[2];
DWORD Data;
DWORD Pos;
UpdateNTGPC = TRUE;
if (pOrgNTRes) {
LocalFree(pOrgNTRes);
pOrgNTRes = NULL;
}
if (pCurNTRes) {
LocalFree(pCurNTRes);
pCurNTRes = NULL;
}
//
// Found out the size needed
//
SizeA = (WORD)sizeof(NT_RES) -
(WORD)sizeof(pCurNTRes->awOffset) +
(WORD)(sizeof(WORD) * NR_SLOTS * (DWORD)TotalModels);
SizeA = (WORD)((SizeA + 3) & 0xfffc);
SizeB = (WORD)sizeof(MODELRES) * (WORD)TotalModels;
SizeNTGPC = SizeA + SizeB;
// DBGP("\nNTGPC(%u), %u + %u = %u bytes"
// ARGU(TotalModels) ARGU(SizeA) ARGU(SizeB) ARGU(SizeNTGPC));
if ((!(pOrgNTRes = (PNT_RES)LocalAlloc(LPTR, SizeNTGPC))) ||
(!(pCurNTRes = (PNT_RES)LocalAlloc(LPTR, SizeNTGPC)))) {
if (pOrgNTRes) {
LocalFree(pOrgNTRes);
pOrgNTRes = NULL;
}
MessageBox(hDlg,
PRES_STR(IDS_NO_MEM_FOR_NTGPC),
PRES_STR(IDS_APP_TITLE),
MB_OK);
return(FALSE);
}
//
// We will initialize to all default before process to read the NT.GPC
//
pOrgNTRes->dwIdent = NR_IDENT;
pOrgNTRes->dwFlags = NR_IFIMET;
pOrgNTRes->dwVersion = NR_VERSION;
pOrgNTRes->cjThis = (WORD)SizeA;
pOrgNTRes->cModels = (WORD)TotalModels;
pOrgNTRes->cwEntry = NR_SLOTS;
pw = pOrgNTRes->awOffset;
pMR = (PMODELRES)((LPBYTE)pOrgNTRes + SizeA);
for (i = 0; i < TotalModels; i++, pw += 4, SizeA += sizeof(MODELRES)) {
pw[NR_COLOUR] = SizeA;
pw[NR_HALFTONE] = SizeA + sizeof(NR_COLORINFO);
pw[NR_UNUSED0] =
pw[NR_UNUSED1] = 0;
*pMR++ = DefModelRes;
}
//
// Now start to parse the NT.GPC file
//
_llseek(hFileNTGPC, 0, 0);
if ((_lread(hFileNTGPC, &Data, sizeof(DWORD)) == sizeof(DWORD)) &&
(Data == NR_IDENT) &&
(_lread(hFileNTGPC, &Data, sizeof(DWORD)) == sizeof(DWORD))) {
pOrgNTRes->dwFlags = (DWORD)((Data & NR_SEIKO) | NR_IFIMET);
if ((_lread(hFileNTGPC, &Data, sizeof(DWORD)) == sizeof(DWORD)) &&
(Data == NR_VERSION) &&
(_lread(hFileNTGPC, &SizeB, sizeof(WORD)) == sizeof(WORD)) &&
(SizeB) &&
(_lread(hFileNTGPC, &cModels, sizeof(WORD)) == sizeof(WORD)) &&
(cModels) &&
(_lread(hFileNTGPC, &cEntry, sizeof(WORD)) == sizeof(WORD)) &&
(cEntry >= 2)) {
UpdateNTGPC = FALSE;
if (cModels > (WORD)TotalModels) {
DBGP("\nToo Many Models in NT.GPC %u -> %u"
ARGU(cModels) ARGU(TotalModels));
cModels = (WORD)TotalModels;
UpdateNTGPC = TRUE;
}
pMR = (PMODELRES)((LPBYTE)pOrgNTRes + pOrgNTRes->cjThis);
Pos = (LONG)(sizeof(NT_RES) - sizeof(pOrgNTRes->awOffset));
cEntry *= sizeof(WORD);
for (i = 1; i <= (INT)cModels; i++, pMR++, Pos += cEntry) {
if ((!GetNTGPCData(Pos, (LPBYTE)wOffset, sizeof(wOffset))) ||
(!GetNTGPCData((LONG)wOffset[0],
(LPBYTE)&(pMR->ciRes),
sizeof(NR_COLORINFO))) ||
(!GetNTGPCData((LONG)wOffset[1],
(LPBYTE)&(pMR->htRes),
sizeof(NR_HT))) ||
(!ValidateModelRes(pMR))) {
UpdateNTGPC = TRUE;
}
}
}
}
CopyMemory(pCurNTRes, pOrgNTRes, (DWORD)SizeNTGPC);
if (UpdateNTGPC) {
pOrgNTRes->dwVersion ^= 0xffffffff;
}
ShowTitle(hDlg);
return(TRUE);
}
VOID
DisplayCIExyY(
HWND hDlg,
UINT First,
UINT Last
)
{
HWND hCtrl;
LDECI4 FAR *pLDECI4;
LDECI4 FAR *pOrgLDECI4;
INT i;
INT j;
static BYTE Format[] = "%u.%04u";
static BYTE Digit[3] = "442";
static WORD Div[3] = { 10000, 10000, 100 };
BYTE Buf[32];
if (First < IDD_CIE_Rx_TEXT) {
First = IDD_CIE_Rx_TEXT;
}
if (Last > IDD_CIE_Wx_TEXT) {
Last = IDD_CIE_Wx_TEXT;
}
if (First > Last) {
First = IDD_CIE_Rx_TEXT;
Last = IDD_CIE_Wx_TEXT;
}
pLDECI4 = (LDECI4 FAR *)&(pCurMR->ciRes.ci.Red.x) +
(3 * (First - IDD_CIE_Rx_TEXT));
pOrgLDECI4 = (LDECI4 FAR *)&(pOrgMR->ciRes.ci.Red.x) +
(3 * (First - IDD_CIE_Rx_TEXT));
while (First <= Last) {
for (i = 0, j = 0; i < 3; i++, j += 10) {
hCtrl = GetDlgItem(hDlg, First + j);
SetWindowLong(hCtrl,
GWL_USERDATA,
(*pOrgLDECI4 == *pLDECI4) ? DlgLoClr : DlgHiClr);
Format[5] = Digit[i];
sprintf(Buf, Format, (UINT)(*pLDECI4 / Div[i]),
(UINT)(*pLDECI4 % Div[i]));
SetWindowText(hCtrl, Buf);
++pLDECI4;
++pOrgLDECI4;
}
++First;
}
}
VOID
DisplayGamma(
HWND hDlg
)
{
HWND hCtrl;
LDECI4 FAR *pLDECI4;
LDECI4 FAR *pOrgLDECI4;
INT i;
INT j;
BYTE Buf[32];
static BYTE Clr[3] = "RGB";
pLDECI4 = (LDECI4 FAR *)&(pCurMR->ciRes.ci.RedGamma);
pOrgLDECI4 = (LDECI4 FAR *)&(pOrgMR->ciRes.ci.RedGamma);
for (i = 0, j = IDD_GAMMA_R_TEXT; i < 3; i++, j++) {
hCtrl = GetDlgItem(hDlg, j);
SetWindowLong(hCtrl,
GWL_USERDATA,
(*pOrgLDECI4 == *pLDECI4) ? DlgLoClr : DlgHiClr);
sprintf(Buf, "%c=%u.%04u", Clr[i],
(UINT)(*(pLDECI4 + 0) / 10000),
(UINT)(*(pLDECI4 + 0) % 10000));
SetWindowText(hCtrl, Buf);
++pLDECI4;
++pOrgLDECI4;
}
}
LPBYTE
GetPelSizeText(
LPBYTE pBuf,
DWORD PelSize
)
{
DWORD mm;
if (PelSize) {
mm = (DWORD)((25400000 + (PelSize >> 1)) / PelSize);
sprintf(pBuf, "1/%ld\" = %2u.%06u mm",
(DWORD)PelSize,
(UINT)(mm / 1000000), (UINT)(mm % 1000000));
} else {
strcpy(pBuf, PRES_STR(IDS_DEVPEL_ZERO));
}
return(pBuf);
}
VOID
DisplayPixelSize(
HWND hDlg
)
{
HWND hCtrl;
DWORD PelSize;
DWORD OrgPelSize;
BYTE Buf[64];
PelSize = (DWORD)(pCurMR->htRes.ulDevicePelsDPI);
OrgPelSize = (DWORD)(pOrgMR->htRes.ulDevicePelsDPI);
hCtrl = GetDlgItem(hDlg, IDD_PELSIZE_TEXT);
SetWindowLong(hCtrl,
GWL_USERDATA,
(PelSize == OrgPelSize) ? DlgLoClr : DlgHiClr);
GetPelSizeText(Buf, PelSize);
SetWindowText(hCtrl, Buf);
}
VOID
DisplayHTPatSize(
HWND hDlg
)
{
HWND hCtrl = (HWND)GetDlgItem(hDlg, IDD_HTPAT_SIZE_TEXT);
DWORD CurSize = (DWORD)pCurMR->htRes.ulPatternSize;
SetWindowLong(hCtrl,
GWL_USERDATA,
(CurSize == (DWORD)pOrgMR->htRes.ulPatternSize) ? DlgLoClr :
DlgHiClr);
SetWindowText(hCtrl, pHTPatSize[CurSize]);
}
VOID
DisplayDyeConcentration(
HWND hDlg,
UINT First,
UINT Last
)
{
HWND hCtrl;
LDECI4 FAR *pLDECI4;
LDECI4 FAR *pOrgLDECI4;
BYTE Buf[32];
if (First < IDD_M_IN_C) {
First = IDD_M_IN_C;
}
if (Last > IDD_M_IN_Y) {
Last = IDD_M_IN_Y;
}
if (First > Last) {
First = IDD_M_IN_C;
Last = IDD_M_IN_Y;
}
pLDECI4 = (LDECI4 FAR *)&(pCurMR->ciRes.ci.MagentaInCyanDye) +
(First - IDD_M_IN_C);
pOrgLDECI4 = (LDECI4 FAR *)&(pOrgMR->ciRes.ci.MagentaInCyanDye) +
(First - IDD_M_IN_C);
while (First <= Last) {
hCtrl = GetDlgItem(hDlg, First);
SetWindowLong(hCtrl,
GWL_USERDATA,
(*pOrgLDECI4 == *pLDECI4) ? DlgLoClr : DlgHiClr);
sprintf(Buf, "%u.%02u %%",(UINT)(*pLDECI4 / 100), (UINT)(*pLDECI4 % 100));
SetWindowText(hCtrl, Buf);
++First;
++pLDECI4;
++pOrgLDECI4;
}
}
VOID
DisplayNTGPCFlags(
HWND hDlg
)
{
HWND hCtrl;
BOOL Enable;
hCtrl = GetDlgItem(hDlg, IDD_8BIT_HALFTONE);
SetWindowLong(hCtrl,
GWL_USERDATA,
((pCurNTRes->dwFlags & NR_SEIKO) ==
(pOrgNTRes->dwFlags & NR_SEIKO)) ? DlgLoClr : DlgHiClr);
InvalidateRect(hCtrl, NULL, FALSE);
Enable = (BOOL)((hFileNTGPC == HFILE_ERROR) ?
FALSE : (pCurNTRes->dwFlags & NR_SEIKO));
EnableWindow(GetDlgItem(hDlg, IDD_GAMMA_PUSH), Enable);
EnableWindow(GetDlgItem(hDlg, IDD_GAMMA_R_TEXT), Enable);
EnableWindow(GetDlgItem(hDlg, IDD_GAMMA_G_TEXT), Enable);
EnableWindow(GetDlgItem(hDlg, IDD_GAMMA_B_TEXT), Enable);
}
VOID
DisplayModelGPC(
HWND hDlg
)
{
DisplayCIExyY(hDlg, 1, 0);
DisplayNTGPCFlags(hDlg);
DisplayGamma(hDlg);
DisplayHTPatSize(hDlg);
DisplayPixelSize(hDlg);
DisplayDyeConcentration(hDlg, 1, 0);
}
BOOL
OkSaveNTGPC(
HWND hDlg
)
{
BOOL Proceed = TRUE;
if ((hFileNTGPC != HFILE_ERROR) && (UpdateNTGPC)) {
BYTE Buf[256];
sprintf(Buf, PRES_STR(IDS_OK_SAVE_NTGPC), szNTGPCFile);
switch (MessageBox(hDlg, Buf, PRES_STR(IDS_APP_TITLE), MB_YESNOCANCEL)) {
case IDYES:
_llseek(hFileNTGPC, 0, 0);
_lwrite(hFileNTGPC, (LPVOID)pCurNTRes, (UINT)SizeNTGPC);
//
// Fall through
//
case IDNO:
CopyMemory(pOrgNTRes, pCurNTRes, SizeNTGPC);
UpdateNTGPC = FALSE;
ShowTitle(hDlg);
break;
case IDCANCEL:
Proceed = FALSE;
break;
}
}
return(Proceed);
}
INT
ReadRCFile(
HWND hDlg
)
{
LPWORD pwID;
LPBYTE pData;
PFILEIO pFileIO;
INT i;
INT LastNum;
INT ID;
WORD DoneBits;
BOOL EnableUpdate = TRUE;
BYTE Buf[256];
//
// Firstable: composed the dir\rcfilename
//
ID = GetDlgItemText(hDlg, IDD_RC_DIR, Buf, sizeof(Buf));
strcpy(&Buf[ID], szRCFile);
if (!(pFileIO = (PFILEIO)LocalAlloc(LPTR, sizeof(FILEIO)))) {
MessageBox(hDlg,
PRES_STR(IDS_NO_MEM_FOR_RC),
PRES_STR(IDS_APP_TITLE), MB_OK);
return(-1);
}
if ((pFileIO->hFile = _lopen(Buf, OF_READ)) == HFILE_ERROR) {
sprintf(Buf, PRES_STR(IDS_CANNOT_ACCESS_RC), szRCFile);
MessageBox(hDlg, Buf, PRES_STR(IDS_APP_TITLE), MB_OK);
LocalFree(pFileIO);
return(-1);
}
DoneBits = 0x00;
LastNum = 0;
SendDlgItemMessage(hDlg,
IDD_MODEL_COMBO,
CB_RESETCONTENT,
(WPARAM)0,
(LPARAM)0);
while ((DoneBits != 0x03) && (pData = GetToken(pFileIO, NULL))) {
if (_stricmp(pData, "STRINGTABLE") == 0) {
ID = 1;
while ((ID) && (pData = GetToken(pFileIO, LineEnd))) {
ID = _stricmp(pData, "BEGIN");
}
while ((pData = GetToken(pFileIO, NULL)) &&
(_stricmp(pData, "END")) &&
((ID = atoi(pData)) <= 256)) {
pData = GetToken(pFileIO, DoubleQuote);
sprintf(Buf, "%u: %s", ID, pData + 1);
SendDlgItemMessage(hDlg,
IDD_MODEL_COMBO,
CB_ADDSTRING,
(WPARAM)NULL,
(LPARAM)Buf);
}
while ((pData) &&
(_stricmp(pData, "END")) &&
(pData = GetToken(pFileIO, LineEnd)));
DoneBits |= 0x01;
} else if (i = atoi(pData)) {
LastNum = i;
} else if (_stricmp(pData, "RC_TABLES") == 0) {
if (LastNum > 1) {
if (pData = GetToken(pFileIO, LineEnd)) {
LPBYTE pNTGPC;
pNTGPC = strtok(pData, SepInLine);
while (pData) {
if (pData = strtok(NULL, SepInLine)) {
pNTGPC = pData;
}
}
if (!pNTGPC) {
pNTGPC = szDefNTGPC;
}
strcpy(szNTGPCFile, pNTGPC);
DoneBits |= 0x02;
}
}
} else {
pData = GetToken(pFileIO, LineEnd);
}
}
_lclose(pFileIO->hFile);
LocalFree(pFileIO);
TotalModels = (INT)SendDlgItemMessage(hDlg,
IDD_MODEL_COMBO,
CB_GETCOUNT,
(WPARAM)0,
(LPARAM)0);
if (!(DoneBits & 0x02)) {
MessageBox(hDlg,
PRES_STR(IDS_NO_NTGPC_NAME),
PRES_STR(IDS_APP_TITLE),
MB_OK);
return(TotalModels = 0);
}
if (!(DoneBits & 0x01)) {
MessageBox(hDlg,
PRES_STR(IDS_NO_PRINTER_MODEL),
PRES_STR(IDS_APP_TITLE),
MB_OK);
return(TotalModels = 0);
}
if (!TotalModels) {
MessageBox(hDlg,
PRES_STR(IDS_NO_PRINTER_MODEL),
PRES_STR(IDS_APP_TITLE),
MB_OK);
return(TotalModels = 0);
}
ID = GetDlgItemText(hDlg, IDD_RC_DIR, Buf, sizeof(Buf));
strcpy(&Buf[ID], szNTGPCFile);
if (hFileNTGPC != HFILE_ERROR) {
_lclose(hFileNTGPC);
}
if ((hFileNTGPC = _lopen(Buf, OF_READWRITE)) == HFILE_ERROR) {
if ((hFileNTGPC = _lopen(Buf, OF_READ)) != HFILE_ERROR) {
MessageBox(hDlg,
PRES_STR(IDS_NTGPC_READONLY),
PRES_STR(IDS_APP_TITLE),
MB_OK);
EnableUpdate = FALSE;
}
}
if (hFileNTGPC == HFILE_ERROR) {
if ((hFileNTGPC = _lcreat(Buf, 0)) == HFILE_ERROR) {
i = strlen(strcpy(Buf, PRES_STR(IDS_ERROR_CREATE_FILE)));
i += GetDlgItemText(hDlg, IDD_RC_DIR, &Buf[i], sizeof(Buf) - i);
i += sprintf(&Buf[i], "%s'!", szNTGPCFile);
MessageBox(hDlg, Buf, PRES_STR(IDS_APP_TITLE), MB_OK);
return(TotalModels = 0);
}
}
if (!InitNTGPC(hDlg)) {
_lclose(hFileNTGPC);
hFileNTGPC = HFILE_ERROR;
return(TotalModels = 0);
}
pwID = &DisableGroup[0];
while (DoneBits = *pwID++) {
EnableWindow(GetDlgItem(hDlg, DoneBits), EnableUpdate);
}
if ((!EnableUpdate) &&
(hFileNTGPC != HFILE_ERROR)) {
_lclose(hFileNTGPC);
hFileNTGPC = HFILE_ERROR;
}
return(TotalModels);
}
LONG
APIENTRY
HTPatSizeDlgProc(
HWND hDlg,
UINT Msg,
WPARAM wParam,
LONG lParam
)
/*++
Routine Description:
This is the proc which handle the NTGPC dialog box
Arguments:
Return Value:
Author:
23-Jun-1993 Wed 14:38:34 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
PSCROLL3 pScroll3;
RECT rc;
INT i;
switch(Msg) {
case WM_INITDIALOG: // set the previouse one equal to current setting
SetWindowLong(hDlg, GWL_USERDATA, lParam);
pScroll3 = (PSCROLL3)lParam;
GetWindowRect(pScroll3->hPush, &rc);
SetWindowPos(hDlg, NULL,
rc.left, rc.bottom,
0, 0, SWP_NOSIZE | SWP_NOZORDER);
i = 0;
while (pHTPatSize[i]) {
SendDlgItemMessage(hDlg,
IDD_HTPAT_SIZE_LB,
LB_ADDSTRING,
(WPARAM)NULL,
(LPARAM)pHTPatSize[i++]);
}
SendDlgItemMessage(hDlg,
IDD_HTPAT_SIZE_LB,
LB_SETCURSEL,
(WPARAM)*(pScroll3->pUpdate),
(LPARAM)0);
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDD_HTPAT_SIZE_LB:
if (HIWORD(wParam) == CBN_DBLCLK) {
PostMessage(hDlg,
WM_COMMAND,
MAKEWPARAM(IDOK, 0),
(LPARAM)GetDlgItem(hDlg, IDOK));
}
break;
case IDOK:
pScroll3 = (PSCROLL3)GetWindowLong(hDlg, GWL_USERDATA);
*(pScroll3->pUpdate) = (LDECI4)SendDlgItemMessage(hDlg,
IDD_HTPAT_SIZE_LB,
LB_GETCURSEL,
(WPARAM)0,
(LPARAM)0);
EndDialog(hDlg, 1);
break;
case IDCANCEL:
EndDialog(hDlg, 0);
break;
case IDD_DEFAULT:
case IDD_REVERT:
pScroll3 = (PSCROLL3)GetWindowLong(hDlg, GWL_USERDATA);
SendDlgItemMessage(hDlg,
IDD_HTPAT_SIZE_LB,
LB_SETCURSEL,
(WPARAM)((LOWORD(wParam) == IDD_DEFAULT) ?
*(pScroll3->pDefault) :
*(pScroll3->pOrg)),
(LPARAM)0);
break;
}
break;
default:
return(FALSE);
}
return((BOOL)(Msg != WM_INITDIALOG));
}
LONG
APIENTRY
SCROLL3DlgProc(
HWND hDlg,
UINT Msg,
WPARAM wParam,
LONG lParam
)
/*++
Routine Description:
This is the proc which handle the NTGPC dialog box
Arguments:
Return Value:
Author:
23-Jun-1993 Wed 14:38:34 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
HWND hScroll;
HWND h1stScroll;
PSCROLL3 pScroll3;
UINT IdxBeg;
UINT IdxEnd;
WORD DlgID;
INT Min;
INT Max;
INT Cur;
INT i;
INT j;
RECT rc;
BYTE Buf[128];
if (Msg == WM_INITDIALOG) {
SetWindowLong(hDlg, GWL_USERDATA, lParam);
pScroll3 = (PSCROLL3)lParam;
GetWindowRect(pScroll3->hPush, &rc);
SetWindowPos(hDlg, NULL,
rc.left, rc.bottom,
0, 0, SWP_NOSIZE | SWP_NOZORDER);
if (pScroll3->pPrefix) {
i = sprintf(Buf, "%s ", pScroll3->pPrefix);
GetWindowText(hDlg, &Buf[i], sizeof(Buf) - i);
SetWindowText(hDlg, Buf);
}
for (i = j = 0, h1stScroll = NULL; i < 3; i++) {
if (hScroll = GetDlgItem(hDlg, i + IDD_SCROLL_0)) {
SetWindowLong(hScroll, GWL_USERDATA, i);
SetScrollRange(hScroll,
SB_CTL,
pScroll3->Min[i],
pScroll3->Max[i],
FALSE);
}
if (pScroll3->Step[i] == 0xff) {
if (hScroll) {
EnableWindow(hScroll, FALSE);
}
} else {
if (h1stScroll == NULL) {
h1stScroll = hScroll;
}
pScroll3->Cur[i] = (WORD)(pScroll3->pUpdate[j++]);
}
}
} else if (!(pScroll3 = (PSCROLL3)GetWindowLong(hDlg, GWL_USERDATA))) {
return(FALSE);
}
IdxBeg = 1;
IdxEnd = 0;
switch(Msg) {
case WM_INITDIALOG: // set the previouse one equal to current setting
IdxBeg = 0;
IdxEnd = 2;
break;
case WM_COMMAND:
switch (DlgID = LOWORD(wParam)) {
case IDOK:
Cur = 0;
for (i = j = 0; i < 3; i++) {
if (pScroll3->Step[i] != 0xff) {
if (pScroll3->pUpdate[j] != (LDECI4)pScroll3->Cur[i]) {
++Cur;
pScroll3->pUpdate[j] = (LDECI4)pScroll3->Cur[i];
}
++j;
}
}
EndDialog(hDlg, Cur);
break;
case IDCANCEL:
EndDialog(hDlg, 0);
break;
case IDD_DEFAULT:
case IDD_REVERT:
IdxBeg = 0;
IdxEnd = 2;
for (i = j = 0; i < 3; i++) {
if (pScroll3->Step[i] != 0xff) {
pScroll3->Cur[i] = (WORD)((DlgID == IDD_DEFAULT) ?
pScroll3->pDefault[j++] :
pScroll3->pOrg[j++]);
}
}
break;
}
break;
case WM_HSCROLL:
IdxBeg =
IdxEnd = (UINT)GetWindowLong((HWND)lParam, GWL_USERDATA);
Min = (INT)pScroll3->Min[IdxBeg];
Max = (INT)pScroll3->Max[IdxBeg];
Cur = (INT)pScroll3->Cur[IdxBeg];
switch (LOWORD(wParam)) {
case SB_TOP:
Cur = Min;
break;
case SB_BOTTOM:
Cur = Max;
break;
case SB_PAGEUP:
Cur -= (INT)pScroll3->Step[IdxBeg];
break;
case SB_PAGEDOWN:
Cur += (INT)pScroll3->Step[IdxBeg];
break;
case SB_LINEUP:
--Cur;
break;
case SB_LINEDOWN:
++Cur;
break;
case SB_THUMBPOSITION:
case SB_THUMBTRACK:
Cur = (INT)HIWORD(wParam);
break;
default:
return(FALSE);
}
if (Cur < Min) {
Cur = Min;
} else if (Cur > Max) {
Cur = Max;
}
pScroll3->Cur[IdxBeg] = (WORD)Cur;
break;
default:
return(FALSE);
}
while (IdxBeg <= IdxEnd) {
Cur = (INT)pScroll3->Cur[IdxBeg];
if (hScroll = GetDlgItem(hDlg, IdxBeg + IDD_SCROLL_0)) {
SetScrollPos(hScroll, SB_CTL, (INT)Cur, TRUE);
if (j = (INT)S3Format[pScroll3->Format[IdxBeg]].Div) {
wsprintf(Buf, S3Format[pScroll3->Format[IdxBeg]].Str,
(UINT)(Cur / j), (UINT)(Cur % j));
} else {
GetPelSizeText(Buf, Cur);
}
SetDlgItemText(hDlg, IdxBeg + IDD_SCROLL_TEXT_0, Buf);
}
++IdxBeg;
}
if (Msg == WM_INITDIALOG) {
SetFocus(h1stScroll);
return(FALSE);
} else {
return(TRUE);
}
}
BOOL
APIENTRY
AboutWndProc(
HWND hDlg,
UINT uiMessage,
WPARAM wParam,
LONG lParam
)
{
UNREFERENCED_PARAMETER(lParam);
switch (uiMessage) {
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCANCEL:
case IDOK:
EndDialog (hDlg, TRUE);
break;
}
break;
case WM_INITDIALOG:
return TRUE;
}
return FALSE;
}
BOOL
CALLBACK
EnumNTGPCDlgChild(
HWND hWnd,
LPARAM lParam
)
{
UNREFERENCED_PARAMETER(lParam);
if (GetDlgCtrlID(hWnd) != -1) {
SetWindowLong(hWnd, GWL_USERDATA, (LONG)lParam);
}
return(TRUE);
}
LONG
APIENTRY
NTGPCDlgProc(
HWND hDlg,
UINT Msg,
WPARAM wParam,
LONG lParam
)
/*++
Routine Description:
This is the proc which handle the NTGPC dialog box
Arguments:
Return Value:
Author:
23-Jun-1993 Wed 14:38:34 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
HMENU hSysMenu;
HDC hDC;
LDECI4 *pLDECI4;
LONG lRet;
INT i;
WORD DlgID;
BOOL Update = FALSE;
SCROLL3 Scroll3;
switch(Msg) {
case WM_INITDIALOG:
hSysMenu = GetSystemMenu(hDlg, FALSE);
RemoveMenu(hSysMenu, SC_SIZE, MF_BYCOMMAND);
RemoveMenu(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
AppendMenu(hSysMenu,
MF_ENABLED | MF_STRING,
IDD_ABOUT,
PRES_STR(IDS_ABOUT));
DlgLoClr = GetTextColor(hDC = GetWindowDC(hDlg));
ReleaseDC(hDlg, hDC);
EnumChildWindows(hDlg, EnumNTGPCDlgChild, (LPARAM)DlgLoClr);
ShowTitle(hDlg);
SendDlgItemMessage(hDlg,
IDD_MODEL_COMBO,
CB_SETEXTENDEDUI,
(WPARAM)TRUE,
(LPARAM)NULL);
PostMessage(hDlg, WM_COMMAND, IDD_OPEN_RC, (LPARAM)NULL);
SetFocus(GetDlgItem(hDlg, IDD_MODEL_COMBO));
return(0);
case WM_SYSCOMMAND:
if (wParam == IDD_ABOUT) {
DialogBox(hInstApp,
"NTGPCEDTABOUT",
hDlg,
(DLGPROC)AboutWndProc);
}
return(FALSE);
case WM_COMMAND:
switch (DlgID = LOWORD(wParam)) {
case IDD_MODEL_COMBO:
if (HIWORD(wParam) == CBN_SELCHANGE) {
ModelIdx = (INT)SendDlgItemMessage(hDlg,
IDD_MODEL_COMBO,
CB_GETCURSEL,
(WPARAM)NULL,
(LPARAM)NULL);
pCurMR = GET_PMR(pCurNTRes, ModelIdx);
pOrgMR = GET_PMR(pOrgNTRes, ModelIdx);
Update = TRUE;
CheckDlgButton(hDlg,
IDD_8BIT_HALFTONE,
(pCurNTRes->dwFlags & NR_SEIKO) ? 1 : 0);
DisplayModelGPC(hDlg);
}
break;
case IDD_PELSIZE_PUSH:
Scroll3 = PelSize_S3;
Scroll3.pUpdate = (LDECI4 FAR *)&(pCurMR->htRes.ulDevicePelsDPI);
Scroll3.pOrg = (LDECI4 FAR *)&(pOrgMR->htRes.ulDevicePelsDPI);
Scroll3.pDefault = (LDECI4 FAR *)&(DefModelRes.htRes.ulDevicePelsDPI);
Scroll3.hPush = GetDlgItem(hDlg, DlgID);
if (DialogBoxParam(hInstApp,
"PELSIZE_ADJ",
hDlg,
(DLGPROC)SCROLL3DlgProc,
(LPARAM)(LPVOID)&Scroll3)) {
Update = TRUE;
DisplayPixelSize(hDlg);
}
break;
case IDD_CIE_R_PUSH:
case IDD_CIE_G_PUSH:
case IDD_CIE_B_PUSH:
case IDD_CIE_C_PUSH:
case IDD_CIE_M_PUSH:
case IDD_CIE_Y_PUSH:
case IDD_CIE_W_PUSH:
i = (INT)(DlgID - IDD_CIE_R_PUSH);
Scroll3 = CIExyY_S3;
pLDECI4 = (LDECI4 FAR *)&(pCurMR->ciRes.ci.Red.x);
Scroll3.pUpdate = pLDECI4 + (3 * i);
pLDECI4 = (LDECI4 FAR *)&(pOrgMR->ciRes.ci.Red.x);
Scroll3.pOrg = pLDECI4 + (3 * i);
pLDECI4 = (LDECI4 FAR *)&(DefModelRes.ciRes.ci.Red.x);
Scroll3.pDefault = pLDECI4 + (3 * i);
Scroll3.pPrefix = pCIExyYPrefix[i];
Scroll3.hPush = GetDlgItem(hDlg, DlgID);
if (DlgID == IDD_CIE_W_PUSH) {
Scroll3.Min[2] = CIE_W_MIN;
Scroll3.Max[2] = CIE_W_MAX;
}
if (DialogBoxParam(hInstApp,
"CIE_xyY_ADJ",
hDlg,
(DLGPROC)SCROLL3DlgProc,
(LPARAM)(LPVOID)&Scroll3)) {
Update = TRUE;
DisplayCIExyY(hDlg, DlgID, DlgID);
}
break;
case IDD_8BIT_HALFTONE:
pCurNTRes->dwFlags &= ~NR_SEIKO;
if (IsDlgButtonChecked(hDlg, IDD_8BIT_HALFTONE)) {
pCurNTRes->dwFlags |= NR_SEIKO;
}
DisplayNTGPCFlags(hDlg);
Update = TRUE;
break;
case IDD_GAMMA_PUSH:
Scroll3 = CIEGamma_S3;
Scroll3.pUpdate = (LDECI4 FAR *)&(pCurMR->ciRes.ci.RedGamma);
Scroll3.pOrg = (LDECI4 FAR *)&(pOrgMR->ciRes.ci.RedGamma);
Scroll3.pDefault = (LDECI4 FAR *)&(DefModelRes.ciRes.ci.RedGamma);
Scroll3.pPrefix = NULL;
Scroll3.hPush = GetDlgItem(hDlg, DlgID);
if (DialogBoxParam(hInstApp,
"CIE_RGB_ADJ",
hDlg,
(DLGPROC)SCROLL3DlgProc,
(LPARAM)(LPVOID)&Scroll3)) {
Update = TRUE;
DisplayGamma(hDlg);
}
break;
case IDD_HTPAT_SIZE_PUSH:
Scroll3.pUpdate = &(pCurMR->htRes.ulPatternSize);
Scroll3.pOrg = &(pOrgMR->htRes.ulPatternSize);
Scroll3.pDefault = &(DefModelRes.htRes.ulPatternSize);
Scroll3.hPush = GetDlgItem(hDlg, DlgID);
if (DialogBoxParam(hInstApp,
"HTPATSIZE_ADJ",
hDlg,
(DLGPROC)HTPatSizeDlgProc,
(LPARAM)(LPVOID)&Scroll3)) {
DisplayHTPatSize(hDlg);
Update = TRUE;
}
break;
case IDD_DYE_C_PUSH:
case IDD_DYE_M_PUSH:
case IDD_DYE_Y_PUSH:
i = (INT)(DlgID - IDD_DYE_C_PUSH);
Scroll3 = CIEDye_S3;
pLDECI4 = (LDECI4 FAR *)&(pCurMR->ciRes.ci.MagentaInCyanDye);
Scroll3.pUpdate = pLDECI4 + (2 * i);
pLDECI4 = (LDECI4 FAR *)&(pOrgMR->ciRes.ci.MagentaInCyanDye);
Scroll3.pOrg = pLDECI4 + (2 * i);
pLDECI4 = (LDECI4 FAR *)&(DefModelRes.ciRes.ci.MagentaInCyanDye);
Scroll3.pDefault = pLDECI4 + (2 * i);
Scroll3.pPrefix = pDyePrefix[i];
Scroll3.hPush = GetDlgItem(hDlg, DlgID);
Scroll3.Step[i] = 0xff;
Scroll3.Cur[i] = 10000;
if (DialogBoxParam(hInstApp,
"CIE_DYE_ADJ",
hDlg,
(DLGPROC)SCROLL3DlgProc,
(LPARAM)(LPVOID)&Scroll3)) {
Update = TRUE;
DisplayDyeConcentration(hDlg, DlgID, DlgID);
}
break;
case IDCANCEL:
SendDlgItemMessage(hDlg,
IDD_MODEL_COMBO,
CB_SHOWDROPDOWN,
(WPARAM)FALSE,
(LPARAM)NULL);
break;
case IDOK:
if (OkSaveNTGPC(hDlg)) {
EndDialog(hDlg, 0);
}
break;
case IDD_OPEN_RC:
if (OkSaveNTGPC(hDlg)) {
do {
if (GetNewRCFileName(hDlg)) {
ReadRCFile(hDlg);
} else {
if (!TotalModels) {
EndDialog(hDlg, 0);
return(1);
}
}
} while (TotalModels == 0);
ShowTitle(hDlg);
SendDlgItemMessage(hDlg,
IDD_MODEL_COMBO,
CB_SETCURSEL,
(WPARAM)0,
(LPARAM)NULL);
SendMessage(hDlg,
WM_COMMAND,
MAKEWPARAM(IDD_MODEL_COMBO, CBN_SELCHANGE),
(LPARAM)GetDlgItem(hDlg, IDD_MODEL_COMBO));
}
break;
case IDD_SAVE:
OkSaveNTGPC(hDlg);
break;
case IDD_DEFAULT:
*pCurMR = DefModelRes;
Update = TRUE;
DisplayModelGPC(hDlg);
break;
case IDD_REVERT:
*pCurMR = *pOrgMR;
pCurNTRes->dwFlags = pOrgNTRes->dwFlags;
Update = TRUE;
DisplayModelGPC(hDlg);
break;
case IDD_COPY:
MRCopyBuf = *pCurMR;
EnableWindow(GetDlgItem(hDlg, IDD_PASTE), TRUE);
break;
case IDD_PASTE:
*pCurMR = MRCopyBuf;
Update = TRUE;
DisplayModelGPC(hDlg);
break;
}
break;
case WM_CTLCOLORBTN:
case WM_CTLCOLORSTATIC:
case WM_CTLCOLOREDIT:
lRet = DefWindowProc(hDlg, Msg, wParam, lParam);
if ((HWND)lParam != (HWND)-1) {
SetTextColor((HDC)wParam,
GetWindowLong((HWND)lParam, GWL_USERDATA));
}
return(lRet);
case WM_SIZE:
if (wParam == SIZE_MINIMIZED) {
SetWindowPos(hDlg, NULL,
0, 0,
GetSystemMetrics(SM_CXICON),
GetSystemMetrics(SM_CYICON),
SWP_NOMOVE | SWP_NOZORDER);
EnableMenuItem(GetSystemMenu(hDlg, FALSE),
SC_MINIMIZE,
MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(GetSystemMenu(hDlg, FALSE),
SC_RESTORE,
MF_BYCOMMAND | MF_ENABLED);
return(0);
} else if (wParam == SIZE_RESTORED) {
EnableMenuItem(GetSystemMenu(hDlg, FALSE),
SC_RESTORE,
MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(GetSystemMenu(hDlg, FALSE),
SC_MINIMIZE,
MF_BYCOMMAND | MF_ENABLED);
}
break;
case WM_ERASEBKGND:
if (IsIconic(hDlg)) {
DrawIcon((HDC)wParam, 0, 0, hIconApp);
return(TRUE);
} else {
return(FALSE);
}
break;
case WM_PAINT:
if (IsIconic(hDlg)) {
PAINTSTRUCT ps;
DrawIcon(BeginPaint(hDlg, &ps),
ps.rcPaint.left,
ps.rcPaint.top,
hIconApp);
EndPaint(hDlg, &ps);
return(TRUE);
}
return(FALSE);
case WM_CLOSE:
PostMessage(hDlg,
WM_COMMAND,
MAKEWPARAM(IDOK, 0),
(LPARAM)GetDlgItem(hDlg, IDOK));
break;
default:
return(FALSE);
}
if ((Update) &&
((Update = (BOOL)memcmp(pOrgNTRes,
pCurNTRes,
SizeNTGPC)) != UpdateNTGPC)) {
UpdateNTGPC = Update;
ShowTitle(hDlg);
}
return(1);
}
LONG
APIENTRY
AppWndProc(
HWND hWnd,
UINT Msg,
WPARAM wParam,
LONG lParam
)
/*++
Routine Description:
This is the main application's Window proc
Arguments:
Per Window Proc
Return Value:
LONG
Author:
23-Jun-1993 Wed 14:30:08 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
switch (Msg) {
case WM_CREATE:
hWndApp = hWnd;
DialogBoxParam(hInstApp, "NTGPCDLG", hWnd, (DLGPROC)NTGPCDlgProc, 0);
DestroyWindow(hWnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
if (pOrgNTRes) {
LocalFree(pOrgNTRes);
pOrgNTRes = NULL;
}
if (pCurNTRes) {
LocalFree(pCurNTRes);
pCurNTRes = NULL;
}
if (hFileNTGPC) {
_lclose(hFileNTGPC);
hFileNTGPC = HFILE_ERROR;
}
break;
default:
return(DefWindowProc(hWnd, Msg, wParam, lParam));
}
return(0L);
}
INT
WINAPI
WinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR pCmdLine,
INT ShowCmd
)
/*++
Routine Description:
This is the application main entry point
Arguments:
hInstance -
hPrevInstance -
pCmdLine -
ShowCmd -
Return Value:
LONG (Msg.wParam)
Author:
23-Jun-1993 Wed 14:17:34 created -by- Daniel Chou (danielc)
Revision History:
--*/
{
WNDCLASS WndClass;
HANDLE hAccel;
MSG Msg;
hIconApp = LoadIcon(hInstance, szAppIcon);
if (!hPrevInstance) {
WndClass.style = CS_DBLCLKS;
WndClass.lpfnWndProc = AppWndProc;
WndClass.cbClsExtra = 0;
WndClass.cbWndExtra = 0;
WndClass.hInstance = hInstance;
WndClass.hIcon = hIconApp;
WndClass.hCursor = LoadCursor (NULL, IDC_ARROW);
WndClass.hbrBackground = GetStockObject (BLACK_BRUSH);
WndClass.lpszMenuName = szAppName;
WndClass.lpszClassName = szAppName;
if (!RegisterClass (&WndClass)) {
return(FALSE);
}
}
LoadStringFromRes(hInstApp = hInstance);
hWndApp = CreateWindow(szAppName,
szAppName,
WS_OVERLAPPED |
// WS_VISIBLE |
WS_CAPTION |
WS_SYSMENU |
WS_MAXIMIZEBOX |
WS_MINIMIZEBOX |
WS_CLIPCHILDREN |
WS_THICKFRAME,
CW_USEDEFAULT,
0,
GetSystemMetrics(SM_CXSCREEN) * 2 / 3,
GetSystemMetrics(SM_CYSCREEN) * 2 / 3,
NULL,
NULL,
hInstance,
NULL);
hAccel = LoadAccelerators(hInstance, szAppAccel);
ShowWindow(hWndApp, SW_HIDE);
while (GetMessage(&Msg, NULL, 0, 0)) {
if (!TranslateAccelerator(Msg.hwnd, hAccel, &Msg)) {
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
}
return(Msg.wParam);
}