LOCAL BOOL ShieldFloat_OnInitDialog(HWND hDlg, HWND hWndFocus, LPARAM lParam)
/************************************************************************/
{
int i;
BOOL active;
long Color;
RestorePopup( hDlg, "xyShield", RightPopup );
for (i=0; i<NUM_COLORMASKS; i++)
{
InitDlgItemSpin( hDlg, IDC_MASKRANGE1 + i,
ColorMask.MaskRange[i], NO, 0, 100 );
active = ColorMask.Mask & (1 << i);
CheckDlgButton( hDlg, IDC_MASKACTIVE1 + i, active );
CopyRGB(&ColorMask.MaskColor[i].rgb, &Color);
SetWindowLong( GetDlgItem( hDlg, IDC_MASKCOLOR1+i ), GWL_ACTIVE,
Color );
}
CheckComboItem( hDlg, IDC_SHIELDSELECT, IDC_MASKINCLUDE,IDC_MASKEXCLUDE,
ColorMask.Include ? IDC_MASKINCLUDE : IDC_MASKEXCLUDE);
CheckDlgButton( hDlg, IDC_SHIELD_IFHIDDEN, !ColorMask.IfHidden );
SetupShield();
ColorMask.On = YES;
ControlEnable( hDlg, IDC_PREVIEW, ColorMask.Mask );
ControlEnable( hDlg, IDC_RESET, NO );
return(TRUE);
}
static long RGB2Pixel_24(LPFRAME lpFrame, LPRGB lpFullRGB)
{
long lColor = 0;
CopyRGB(lpFullRGB, &lColor);
return(lColor);
}
void CChromaDlg::UpdateChromaMask(int i, LPCOLORINFO lpColor)
{
HWND hDlg = GetSafeHwnd();
long lColor;
;
lpChromaMask->UpdateChromaMask(i, lpColor);
CopyRGB(&lpChromaMask->MaskColor[i].rgb, &lColor );
SetWindowLong (::GetDlgItem(hDlg, IDC_MASKCOLOR1+i), GWL_ACTIVE, lColor);
::InvalidateRect(::GetDlgItem(hDlg, IDC_MASKCOLOR1+i), NULL, FALSE);
}
static void PutPixel_24(
LPFRAME lpFrame,
LPLONG lpSrcPixel,
LPTR lpDst,
int iPixelCount)
{
while(iPixelCount--)
{
CopyRGB(lpSrcPixel, lpDst);
lpSrcPixel++;
lpDst+=3;
}
}
static void GetPixel_24(
LPFRAME lpFrame,
LPTR lpSrc,
LPLONG lpDstPixel,
int iPixelCount)
{
while(iPixelCount-- > 0)
{
*lpDstPixel = 0;
CopyRGB(lpSrc, lpDstPixel);
lpDstPixel++;
lpSrc+=3;
}
}
VOID CExpandImageDlg::DoExpandInits( )
/***********************************************************************/
{
long Color;
HWND hWnd = GetSafeHwnd();
InitDlgItemSpinFixed(hWnd, IDC_HEIGHT, m_Height, YES, 0L, FGET(9999,1) );
InitDlgItemSpinFixed(hWnd, IDC_WIDTH, m_Width, YES, 0L, FGET(9999,1) );
InitDlgItemSpinFixed(hWnd, IDC_EXPANDLEFT, m_Left, YES, 0L, FGET(9999,1) );
InitDlgItemSpinFixed(hWnd, IDC_EXPANDRIGHT,m_Width-m_OrigWidth-m_Left, YES, 0L, FGET(9999,1) );
InitDlgItemSpinFixed(hWnd, IDC_EXPANDTOP, m_Top, YES, 0L, FGET(9999,1) );
InitDlgItemSpinFixed(hWnd, IDC_EXPANDBOTTOM,m_Height-m_OrigHeight-m_Top, YES, 0L, FGET(9999,1) );
ImageMemory( hWnd, IDC_MEMORY, m_Width, m_Height, m_Resolution,m_Depth );
CheckComboItem(hWnd,IDC_PREF_UNITS, IDC_PREF_UNITFIRST,IDC_PREF_UNITLAST, m_Units);
ControlEnable(hWnd, IDOK, FALSE);
SetUnitLabels(hWnd);
SetColorInfo(&m_FillColor, &m_FillColor, CS_GRAY);
CopyRGB( &m_FillColor.rgb, &Color );
SetWindowLong( ::GetDlgItem(hWnd,IDC_FILLINCOLOR), GWL_ACTIVE, Color );
}
static void SetPixel_24(
long lPixel,
LPTR lpDst,
int iPixelCount)
{
RGBS rgb;
int iRed, iGrn, iBlu;
CopyRGB(&lPixel, &rgb);
iRed = rgb.red;
iGrn = rgb.green;
iBlu = rgb.blue;
while(iPixelCount-- > 0)
{
*lpDst++ = iRed;
*lpDst++ = iGrn;
*lpDst++ = iBlu;
}
}
/* callback for palette-change choice */
void pal_ch_cb(FL_OBJECT *a, long l)
{
const char *ch;
char **current_xpm;
ch = fl_get_choice_text( a );
/* copy the RGB selected by the user to the "current" RGB. */
if( !strcmp(ch,PAL_DOOM) )
CopyRGB( DAC_Reg, doom_rgb);
else if( !strcmp(ch,PAL_HERETIC) )
CopyRGB( DAC_Reg, heretic_rgb);
else if( !strcmp(ch,PAL_E_HERETIC) )
CopyRGB( DAC_Reg, E_HERETIC_rgb);
else if( !strcmp(ch,PAL_HEXEN) )
CopyRGB( DAC_Reg, hexen_rgb);
else if( !strcmp(ch,PAL_STRIFE) )
CopyRGB( DAC_Reg, strife_rgb);
else if( !strcmp(ch, PAL_USER) && USER_rgb )
CopyRGB( DAC_Reg, USER_rgb);
else /* this should not happen */
Abort("unknown palette type!\n");
CreateXpmPalette( DAC_Reg, keep_transparent_color );
/* redraw current image */
if ( ( current_xpm = CreateXpmImage( 0, 0, 0, 1, NULL)) ) {
fl_free_pixmap_pixmap( img_pxm );
fl_set_pixmap_data( img_pxm, current_xpm );
}
}
BOOL CExpandImageDlg::OnCommand(WPARAM wParam, LPARAM lParam)
{
int id = LOWORD(wParam); //ID of control
WORD codeNotify = HIWORD(wParam); //Control notification code
HWND hControl = (HWND) lParam; //Handle of control
LPIMAGE lpImage;
FRMTYPEINFO TypeInfo;
long Color;
switch (id)
{
case IDC_EXPANDLEFT:
case IDC_EXPANDRIGHT:
case IDC_EXPANDTOP:
case IDC_EXPANDBOTTOM:
case IDC_HEIGHT:
case IDC_WIDTH:
case IDC_PREF_UNITS:
DoExpandControls(id, codeNotify);
break;
case IDC_FILLINCOLOR:
if (codeNotify != 1)
break;
lpImage = GetImage();
if (lpImage)
ImgGetTypeInfo(lpImage, &TypeInfo);
else
FrameSetTypeInfo(&TypeInfo, FDT_RGBCOLOR, NULL);
if (TypeInfo.DataType == FDT_LINEART)
{
if(m_FillColor.gray == 255)
m_FillColor.gray = 0;
else
m_FillColor.gray = 255;
SetColorInfo(&m_FillColor, &m_FillColor, CS_GRAY);
}
else if (TypeInfo.DataType == FDT_GRAYSCALE || TypeInfo.DataType == FDT_PALETTECOLOR)
{
if (!PalettePicker(&m_FillColor, NULL, TypeInfo.ColorMap))
break;
}
else if (!ColorPicker(&m_FillColor, NULL))
break;
CopyRGB( &m_FillColor.rgb, &Color );
SetWindowLong(::GetDlgItem(GetSafeHwnd(),IDC_FILLINCOLOR), GWL_ACTIVE, Color );
AstralControlRepaint(GetSafeHwnd(), IDC_FILLINCOLOR);
break;
case IDOK:
if ( (FMUL( m_Resolution, m_Width ) > MAX_IMAGE_WIDTH) ||
(FMUL( m_Resolution, m_Height) > MAX_IMAGE_HEIGHT))
{
Message( IDS_ETOOWIDE );
break;
}
SetUnitResolution( 0 );
Control.Units = m_SaveUnits;
SetUnitInfo((UNIT_TYPE)(Control.Units-IDC_PREF_UNITINCHES), Control.UnitRes,
Control.Points);
AstralDlgEnd( GetSafeHwnd(), TRUE );
break;
default:
break;
}
return CPPViewModalDlg::OnCommand(wParam, lParam);
}
/* Reads files and initializes things. This is mostly from
Tormod's main() ... */
Int4 ReadFiles(void)
{
char *pStr;
char Buf[10];
Int4 NumOfLumps;
Int4 DirOfs;
Int4 LumpInx;
Int4 NumLargeImg;
Int4 UsefulEntries;
Int4 NumWadType[NUM_TAG];
Int4 LargestImgEntry;
pStr = Get_pSearchList(NULL);
if (pStr != NULL)
pStr = FindFile(IniFileName, pStr);
if (pStr != NULL) {
Message("Ini file \"%s\" found\n", pStr);
ReadIniFile(pStr);
if (Ext_WAV_Player[0] != '\0')
Message("WAV : \"%s\"\n", Ext_WAV_Player);
if (Ext_MUS_Player[0] != '\0')
Message("MUS : \"%s\"\n", Ext_MUS_Player);
if (Ext_PCX_Viewer[0] != '\0')
Message("PCX : \"%s\"\n", Ext_PCX_Viewer);
}
else
Message("Ini file \"%s\" NOT found\n", IniFileName);
if ( pPalFileSpec ) {
USER_rgb = malloc( 3*256 );
if ( !USER_rgb )
Abort("Can't get mem for palette...\n");
ReadPal(pPalFileSpec, USER_rgb);
CopyRGB( DAC_Reg, USER_rgb );
Message("Palette file '%s' loaded successfully\n", pPalFileSpec);
}
else
CopyRGB( DAC_Reg, doom_rgb); /* set doom palette as default */
CreateXpmPalette( DAC_Reg, keep_transparent_color);
if ((WADfp = fopen(pWadFileSpec, "rb")) == NULL)
Abort("unable to open input file \"%s\"", pWadFileSpec);
fgetc(WADfp); /* Waste the I or P before WAD */
fread(Buf, sizeof(char), 3, WADfp);
if (memcmp(Buf, "WAD", 3) != 0)
Abort("the file \"%s\" is not a proper wad file", pWadFileSpec);
fread(&NumOfLumps, sizeof(Int4), 1, WADfp);
fread(&DirOfs, sizeof(Int4), 1, WADfp);
Message("Number of wad entries: %d\nWad directory offset: 0x%x\n",
NumOfLumps, DirOfs);
fseek(WADfp, DirOfs, SEEK_SET);
/* Let's be real careful... */
if ((NumOfLumps * sizeof(Directory)) > UINT_MAX)
Abort("error, directory table too large,"
" cannot malloc more than (%u) bytes", UINT_MAX);
if ((pDirEnt = malloc(NumOfLumps * sizeof(Directory))) == NULL)
Abort("error, no memory for wad directory table");
if ((pEntryTag = calloc(NumOfLumps, sizeof(char))) == NULL)
Abort("error, no memory for wad directory tag table");
if (fread(pDirEnt, sizeof(Directory), NumOfLumps, WADfp) != NumOfLumps)
Abort("error reading wad directory");
BuildWadDir(WADfp, pDirEnt, pEntryTag, NumOfLumps);
/* The WAD Directory contains many entries of no value to us, these
entries forms "holes" in pDirEnt. We need a one-to-one
correspondance between the line in the browser and the directory
entry, so we build a "linear map" : The entries in the linear map
are indices to pDirEnt (and pEntryTag), omitting the holes. */
LinearMap = BulidLinearMap(pDirEnt, pEntryTag, NumOfLumps, &UsefulEntries);
if ( !LinearMap )
Abort("\nerror building wad directory linear map");
Message("\nUseful WAD Entries : %d\n", UsefulEntries);
/* To make sure we find something */
memset(NumWadType, 0, sizeof(NumWadType));
LargestImgEntry = 0;
/* The number of large images discarded because malloc can't handle
* them
*/
NumLargeImg = 0;
/* I want to count the number of each type in the wad file. Can't
* use the TAG_FLAT and such directly since they are bitmasks
*/
for (LumpInx = 0; LumpInx < NumOfLumps; LumpInx++) {
/* Is this image to large for malloc ? */
if ((pEntryTag[LumpInx] & TAG_GFX) && pDirEnt[LumpInx].size > MAX_IMG_SIZ)
{
pEntryTag[LumpInx] = TAG_NONE;
NumLargeImg++;
continue;
}
if (pEntryTag[LumpInx] != 0)
NumWadType[MapBitMaskToInx(pEntryTag[LumpInx])]++;
if ( (pEntryTag[LumpInx] & TAG_GFX) &&
pDirEnt[LumpInx].size > LargestImgEntry)
LargestImgEntry = pDirEnt[LumpInx].size;
}
Message("\nMUS entries: %d\n", NumWadType[MapBitMaskToInx(TAG_MUS)]);
Message("SFX entries: %d\n", NumWadType[MapBitMaskToInx(TAG_SFX)]);
Message("FLAT entries: %d\n", NumWadType[MapBitMaskToInx(TAG_FLAT)]);
Message("FULL entries: %d\n", NumWadType[MapBitMaskToInx(TAG_FULL)]);
Message("IMAGE entries: %d\n", NumWadType[MapBitMaskToInx(TAG_IMG)]);
Message("HIRES entries: %d\n", NumWadType[MapBitMaskToInx(TAG_HIRES)]);
if ( !UsefulEntries )
Abort("There are no MUS, SFX, FLAT, FULL, IMAGE or HIRES"
"entries in this wad");
if (LargestImgEntry != 0) {
if ((pBitMap = calloc(LargestImgEntry, sizeof(char))) == NULL)
Abort("error, no memory for image buffer");
}
return UsefulEntries;
}
BOOL CChromaDlg::OnCommand(WPARAM wParam, LPARAM lParam)
{
HWND hDlg = GetSafeHwnd();
BOOL bReturn = TRUE;
UINT id = LOWORD(wParam);
HWND hControl = (HWND)lParam;
int codeNotify = HIWORD(wParam);
int i;
long Color;
HWND hActiveWnd;
char Buff[10];
BYTE mask;
hActiveWnd = m_pView->GetSafeHwnd();
switch (id)
{
case IDC_CHROMASELECT:
i = TableHandleCombo(hDlg, &iCombo[0], nCombo, id, codeNotify);
if (i != IDC_CHROMA_NORMAL && i != IDC_CHROMA_HSL && i != IDC_CHROMA_LUMIN)
break;
lpChromaMask->ChromaColorMode = i;
lpChromaMask->SetupChroma();
break;
case IDC_MAP_PROBE:
::GetWindowText(hControl, Buff, 10);
id = atoi(Buff);
if (id < 1 || id > 8)
break;
id += IDC_MASKCOLOR1 - 1;
GetDlgItem(id)->ShowWindow(SW_SHOW);
GetDlgItem(id)->SetFocus();
::ShowWindow(hControl, SW_HIDE);
case IDC_MASKCOLOR1:
case IDC_MASKCOLOR2:
case IDC_MASKCOLOR3:
case IDC_MASKCOLOR4:
case IDC_MASKCOLOR5:
case IDC_MASKCOLOR6:
case IDC_MASKCOLOR7:
case IDC_MASKCOLOR8:
lpChromaMask->ActiveChromaMask = i = id - IDC_MASKCOLOR1;
if (codeNotify != 1 /*Not A DoubleClick*/)
{
if (hActiveWnd)
bProbePending = YES;
}
else
{
bProbePending = NO;
if (!ColorPicker(&lpChromaMask->MaskColor[i], NULL))
break;
CopyRGB(&lpChromaMask->MaskColor[i].rgb, &Color);
SetWindowLong(::GetDlgItem(hDlg, id), GWL_ACTIVE, Color);
AstralControlRepaint(hDlg, IDC_MASKCOLOR1+i);
}
mask = 1 << (id - IDC_MASKCOLOR1);
if (lpChromaMask->Mask & mask)
break;
id = id - IDC_MASKCOLOR1 + IDC_MASKACTIVE1;
case IDC_MASKACTIVE1:
case IDC_MASKACTIVE2:
case IDC_MASKACTIVE3:
case IDC_MASKACTIVE4:
case IDC_MASKACTIVE5:
case IDC_MASKACTIVE6:
case IDC_MASKACTIVE7:
case IDC_MASKACTIVE8:
{
mask = 1 << (id - IDC_MASKACTIVE1);
lpChromaMask->Mask ^= mask;
CheckDlgButton(id, lpChromaMask->Mask & mask);
lpChromaMask->SetupChroma();
}
break;
case IDC_CHROMA_FADE:
if (::GetFocus() != ::GetDlgItem(hDlg, id))
break;
if ( codeNotify == EN_CHANGE )
{
BOOL Bool;
lpChromaMask->Fade = GetDlgItemSpin(hDlg, id, &Bool, NO);
lpChromaMask->SetupChroma();
}
break;
case IDC_MASKRANGE1:
case IDC_MASKRANGE2:
case IDC_MASKRANGE3:
case IDC_MASKRANGE4:
case IDC_MASKRANGE5:
case IDC_MASKRANGE6:
case IDC_MASKRANGE7:
case IDC_MASKRANGE8:
if (::GetFocus() != ::GetDlgItem(hDlg, id))
break;
if ( codeNotify == EN_CHANGE )
{
BOOL Bool;
lpChromaMask->MaskRange[id-IDC_MASKRANGE1] = GetDlgItemSpin(hDlg, id, &Bool, NO);
lpChromaMask->SetupChroma();
}
break;
case IDC_MASKMODE_ADD:
case IDC_MASKMODE_SUBTRACT:
case IDC_MASKMODE_REVERSE:
lpChromaMask->ChromaCombineMode = SHAPE_REVERSE + (id - IDC_MASKMODE_REVERSE);
CheckRadioButton(IDC_MASKMODE_REVERSE, IDC_MASKMODE_SUBTRACT,id);
break;
case IDC_DELETEMASK:
lpChromaMask->Delete = !lpChromaMask->Delete;
CheckDlgButton(id, lpChromaMask->Delete);
break;
case IDC_CHROMA:
if (hActiveWnd)
{
idLastTool = ActivateTool(id);
CreateProc(hActiveWnd, 0, 0, this);
bPreview = YES;
}
break;
case IDC_RESET:
if ( bPreview )
DeactivateTool();
bPreview = NO;
break;
default:
bReturn = FALSE;
break;
}
return bReturn ? bReturn : CPPViewModalDlg::OnCommand(wParam, lParam);
}
LPPALETTE ReadPalette( LPSTR lpFileName, BOOL bCombine )
/************************************************************************/
{
int ifh; /* file handle( unbuffered) */
FILEBUF ifd; /* file descriptor( buffered) */
short i, iColors;
VERSIONINFO version;
RECINFO rec;
LPTR lpByte;
LPWORD lpWord;
LPLONG lpLong;
BYTE Previous;
BOOL bError;
FNAME szName;
LPPALETTE lpHeadPalette, lpPalette, lpBigPalette;
/* open the palette file */
if ( ( ifh = _lopen( lpFileName, OF_READ)) < 0 )
{
Message( IDS_EOPEN, lpFileName);
return( NULL );
}
/* create a buffered stream to speed access */
FileFDOpenRdr( &ifd, ifh, (LPTR)LineBuffer[0], 16*1024);
// read palette version
version.Length = sizeof(version.Number);
version.Type = PALFILE_VERSION;
FileRead(&ifd, (LPTR)&version, sizeof(version));
#ifdef _MAC
swapw(&version.Length);
swapw(&version.Number);
#endif
if (ifd.err ||
version.Type != PALFILE_VERSION ||
version.Length != sizeof(version.Number) ||
version.Number > CURRENT_VERSION)
{
Message(IDS_INVALIDPALETTE, lpFileName);
_lclose(ifh);
return(NULL);
}
rec.Type = 0;
lpHeadPalette = NULL;
lpPalette = NULL;
bError = NO;
while (!bError && !ifd.err && rec.Type != PALFILE_END)
{
Previous = rec.Type;
FileRead(&ifd, (LPTR)&rec, sizeof(RECINFO));
#ifdef _MAC
swapw(&rec.Length);
#endif
if (ifd.err)
break;
switch (rec.Type)
{
case PALFILE_VERSION:
bError = YES;
break;
case PALFILE_COUNT:
lpByte = Alloc((long)rec.Length);
FileRead(&ifd, lpByte, rec.Length);
FreeUp(lpByte);
break;
case PALFILE_COLORS:
if (!lpPalette)
{
bError = YES;
break;
}
lpWord = (LPWORD)Alloc((long)rec.Length);
if (!lpWord)
{
Message (IDS_EMEMALLOC);
bError = YES;
break;
}
FileRead(&ifd, (LPTR)lpWord, rec.Length);
if (ifd.err)
{
FreeUp((LPTR)lpWord);
break;
}
#ifdef _MAC
swapw(lpWord);
#endif
iColors = *lpWord;
if ((iColors * sizeof(COLOR) + sizeof(WORD)) != rec.Length)
{
FreeUp((LPTR)lpWord);
bError = YES;
break;
}
lpPalette->iColors = iColors;
if (!iColors)
{
FreeUp((LPTR)lpWord);
break;
}
lpLong = (LPLONG)(lpWord+1);
lpPalette->lpColorInfo =
(LPCOLORINFO)Alloc((long)(sizeof(COLORINFO)*iColors));
if (!lpPalette->lpColorInfo)
{
Message(IDS_EMEMALLOC);
FreeUp((LPTR)lpWord);
bError = YES;
break;
}
for (i = 0; i < iColors; ++i)
{
LPVOID lp = &lpPalette->lpColorInfo[i].rgb;
#ifdef _MAC
swapl((LPDWORD)lp);
#endif
CopyRGB(lpLong+i, lp);
SetColorInfo(
&lpPalette->lpColorInfo[i],
&lpPalette->lpColorInfo[i],
CS_RGB);
}
FreeUp((LPTR)lpWord);
break;
case PALFILE_NAME:
if (Previous == PALFILE_NAME)
{
bError = YES;
break;
}
if (lpPalette)
{
lpHeadPalette = LinkPalette(lpHeadPalette, lpPalette);
lpPalette = NULL;
}
rec.Length = bound(rec.Length, 0, MAX_FNAME_LEN);
FileRead(&ifd, (LPTR)szName, rec.Length);
if (ifd.err)
break;
lpPalette = NewPalette(szName);
if (!lpPalette)
{
Message (IDS_EMEMALLOC);
bError = YES;
break;
}
break;
case PALFILE_GROUP:
if (!lpPalette || (rec.Length != sizeof(lpPalette->dwGroup)))
{
bError = YES;
break;
}
FileRead(&ifd, (LPTR)&lpPalette->dwGroup, rec.Length);
#ifdef _MAC
swapl((LPDWORD)(&lpPalette->dwGroup));
#endif
break;
case PALFILE_LABELS:
if (!lpPalette)
{
bError = YES;
break;
}
lpPalette->lpLabels = Alloc((long)rec.Length);
if (!lpPalette->lpLabels)
{
Message (IDS_EMEMALLOC);
bError = YES;
break;
}
lpPalette->LabelsLength = rec.Length;
FileRead(&ifd, lpPalette->lpLabels, rec.Length);
break;
case PALFILE_FORMAT:
if (!lpPalette || (rec.Length > MAX_STR_LEN))
{
bError = YES;
break;
}
FileRead(&ifd, (LPTR)lpPalette->szFormat, rec.Length);
break;
case PALFILE_END:
if (lpPalette)
{
lpHeadPalette = LinkPalette(lpHeadPalette, lpPalette);
lpPalette = NULL;
}
break;
default:
bError = YES;
break;
}
}
_lclose(ifh);
if (lpPalette)
{
if (lpPalette->lpColorInfo)
FreeUp((LPTR)lpPalette->lpColorInfo);
if (lpPalette->lpLabels)
FreeUp((LPTR)lpPalette->lpLabels);
FreeUp((LPTR)lpPalette);
}
if (ifd.err || bError || rec.Type != PALFILE_END || lpPalette)
{
Message(IDS_INVALIDPALETTE, lpFileName);
FreeUpPalette(lpHeadPalette);
return(NULL);
}
if ( !bCombine || !lpHeadPalette )
return( lpHeadPalette );
if ( !(lpBigPalette = CombinePalettes(lpHeadPalette)) )
Message (IDS_EMEMALLOC);
FreeUpPalette(lpHeadPalette);
return( lpBigPalette );
}
static void Pixel2RGB_24( LPFRAME lpFrame, LPLONG lpColor, LPRGB lpRGB )
{
CopyRGB(lpColor, lpRGB);
}
LOCAL void ShieldFloat_OnCommand(HWND hDlg, int id, HWND hControl, UINT codeNotify)
/************************************************************************/
{
int i;
BOOL Bool, active;
BYTE mask;
long Color;
ITEMID idLastTool;
HWND hActiveWnd;
char Buff[10];
hActiveWnd = GetActiveDoc();
switch (id)
{
case IDC_MAP_PROBE:
GetWindowText(hControl, Buff, 10);
id = atoi(Buff);
if (id < 1 || id > 8)
break;
id += IDC_MASKCOLOR1 - 1;
ShowWindow(GetDlgItem(hDlg, id), SW_SHOW);
SetFocus(GetDlgItem(hDlg, id));
ShowWindow(hControl, SW_HIDE);
case IDC_MASKCOLOR1:
case IDC_MASKCOLOR2:
case IDC_MASKCOLOR3:
case IDC_MASKCOLOR4:
case IDC_MASKCOLOR5:
case IDC_MASKCOLOR6:
case IDC_MASKCOLOR7:
case IDC_MASKCOLOR8:
ColorMask.MaskShield = i = id - IDC_MASKCOLOR1;
if ( codeNotify != 1 /*Not A DoubleClick*/ )
{
if ( hActiveWnd )
bProbePending = YES;
}
else
{
bProbePending = NO;
if ( !ColorPicker( &ColorMask.MaskColor[i], NULL ) )
break;
CopyRGB( &ColorMask.MaskColor[i].rgb, &Color );
SetWindowLong( GetDlgItem( hDlg, id ), GWL_ACTIVE, Color );
AstralControlRepaint( hDlg, IDC_MASKCOLOR1 + i );
}
mask = 1 << (id - IDC_MASKCOLOR1);
if (ColorMask.Mask & mask)
{
SetupShield();
break;
}
id = id - IDC_MASKCOLOR1 + IDC_MASKACTIVE1;
case IDC_MASKACTIVE1:
case IDC_MASKACTIVE2:
case IDC_MASKACTIVE3:
case IDC_MASKACTIVE4:
case IDC_MASKACTIVE5:
case IDC_MASKACTIVE6:
case IDC_MASKACTIVE7:
case IDC_MASKACTIVE8:
mask = 1 << (id - IDC_MASKACTIVE1);
ColorMask.Mask ^= mask;
active = ColorMask.Mask & mask;
CheckDlgButton( hDlg, id, active );
SetupShield();
break;
case IDC_MASKRANGE1:
case IDC_MASKRANGE2:
case IDC_MASKRANGE3:
case IDC_MASKRANGE4:
case IDC_MASKRANGE5:
case IDC_MASKRANGE6:
case IDC_MASKRANGE7:
case IDC_MASKRANGE8:
if ( GetFocus() != GetDlgItem( hDlg, id ) )
break;
if ( codeNotify != EN_CHANGE )
break;
ColorMask.MaskRange[id-IDC_MASKRANGE1] =
GetDlgItemSpin( hDlg, id, &Bool, NO );
SetupShield();
break;
case IDC_SHIELD_IFHIDDEN:
ColorMask.IfHidden = !ColorMask.IfHidden;
CheckDlgButton( hDlg, id, !ColorMask.IfHidden );
break;
case IDC_SHIELDSELECT:
// case IDC_MASKINCLUDE:
// case IDC_MASKEXCLUDE:
if ( !(id = HandleCombo( hDlg, id, codeNotify )) )
break;
ColorMask.Include = ( id == IDC_MASKINCLUDE );
if ( Tool.hRibbon )
SendMessage( Tool.hRibbon, WM_SHIELDCHANGE, 0, 0L );
break;
case IDC_PREVIEW:
if (!hActiveWnd)
break;
idLastTool = ActivateTool(id);
CreateProc( hActiveWnd, 0, 0, idLastTool );
bPreview = YES;
break;
case IDC_RESET:
TurnOffShieldPreview();
break;
default:
break;
}
}
