BOOL PosterizeImage(LPIMAGE lpImage, LPPOSTERIZE_PARMS lpParms)
/************************************************************************/
{
LPMAPS lpMaps;
RECT rUpdate;
UPDATE_TYPE UpdateType;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
return(FALSE);
else if (type == FDT_PALETTECOLOR && ImgGetMask(lpImage))
return(FALSE);
if (!(lpMaps = (LPMAPS)Alloc((long)sizeof(MAPS))))
{
lpParms->Common.StatusCode = SC_MEMERROR;
Message(IDS_EMEMALLOC);
return(FALSE);
}
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
ResetMap( &lpMaps->MasterMap, MAXPOINTS, NO );
ResetMap( &lpMaps->RedMap, MAXPOINTS, NO );
ResetMap( &lpMaps->GreenMap, MAXPOINTS, NO );
ResetMap( &lpMaps->BlueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->BlackMap, MAXPOINTS, NO );
ResetMap( &lpMaps->HueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->SatMap, MAXPOINTS, NO );
lpMaps->MasterMap.Levels = lpParms->MasterInfo.Levels;
lpMaps->MasterMap.Threshold = lpParms->MasterInfo.Threshold;
lpMaps->RedMap.Levels = lpParms->RedInfo.Levels;
lpMaps->RedMap.Threshold = lpParms->RedInfo.Threshold;
lpMaps->GreenMap.Levels = lpParms->GreenInfo.Levels;
lpMaps->GreenMap.Threshold = lpParms->GreenInfo.Threshold;
lpMaps->BlueMap.Levels = lpParms->BlueInfo.Levels;
lpMaps->BlueMap.Threshold = lpParms->BlueInfo.Threshold;
lpMaps->BlackMap.Levels = lpParms->BlackInfo.Levels;
lpMaps->BlackMap.Threshold = lpParms->BlackInfo.Threshold;
MakeMap(&lpMaps->MasterMap);
MakeMap(&lpMaps->RedMap);
MakeMap(&lpMaps->GreenMap);
MakeMap(&lpMaps->BlueMap);
MakeMap(&lpMaps->BlackMap);
lpParms->Common.StatusCode = ApplyMaps(lpImage, lpMaps, lpParms->Common.idDirty, &rUpdate, &UpdateType);
if (UpdateType)
{
lpParms->Common.UpdateType = UpdateType;
lpParms->Common.rUpdateArea = rUpdate;
}
FreeUp(lpMaps);
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
VOID CSizeImageDlg::DoSizeInits( )
{
HWND hDlg = GetSafeHwnd();
LPFRAME lpFrame;
LPIMAGE lpImage = GetImage();
FRMDATATYPE Type = FDT_RGBCOLOR;
ImgGetInfo(lpImage, NULL, NULL, NULL, &Type);
/* Be careful to set all values before doing a SetDlg... with them */
/* The Edit structure is a temorary holding area for sizing dialog boxes */
m_Distortable = NO;
m_MaintainSize = NO;
m_ScaleX = m_ScaleY = 100;
if ( lpImage )
{
lpFrame = ImgGetBaseEditFrame(lpImage);
m_Crop.left = m_Crop.top = 0;
m_Crop.right = lpImage->npix - 1;
m_Crop.bottom = lpImage->nlin - 1;
m_Resolution = m_CropResolution = m_OrigResolution =
FrameResolution(lpFrame);
m_Depth = FrameDepth(lpFrame);
}
else
{
m_Resolution = m_CropResolution = 75;
m_Depth = 1;
}
m_Angle = 0;
m_Width = FGET( CROPWIDTH(), m_CropResolution );
m_Height = FGET( CROPHEIGHT(), m_CropResolution );
CheckDlgButton( IDC_DISTORT, m_Distortable);
CheckDlgButton( IDC_SMARTSIZE, m_SmartSize );
CheckDlgButton( IDC_MAINTAINSIZE, m_MaintainSize );
ControlEnable(hDlg, IDC_DISTORT, !m_MaintainSize);
ControlEnable(hDlg, IDC_MAINTAINSIZE, !m_Distortable );
ControlEnable( hDlg, IDC_SMARTSIZE, !m_MaintainSize &&
!m_Distortable && CANDOTRANSPARENCY(Type));
InitDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES, 0L, FGET(9999,1) );
InitDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES, 0L, FGET(9999,1) );
InitDlgItemSpin( hDlg, IDC_SCALEX, m_ScaleX, YES, 1, 10000 );
InitDlgItemSpin( hDlg, IDC_SCALEY, m_ScaleY, YES, 1, 10000 );
InitDlgItemSpin( hDlg, IDC_RES, m_Resolution, NO, 1, 10000 );
ImageMemory( hDlg, IDC_MEMORY, m_Width, m_Height, m_Resolution,
m_Depth );
CheckComboItem(hDlg, IDC_PREF_UNITS, IDC_PREF_UNITFIRST,
IDC_PREF_UNITLAST, m_Units);
SetUnitLabels();
}
LOCAL void TextureFill_HandleEnable(HWND hDlg, int fFlags)
/************************************************************************/
{
FRMDATATYPE Type = FDT_RGBCOLOR;
ImgGetInfo(GetActiveImage(), NULL, NULL, NULL, &Type);
HandleMergeCombo(hDlg, IDC_MERGEMODE, TRUE, Texture.TextureMergeMode, 0L);
// The following code also goes below and into the shape accelerator
ControlEnable( hDlg, IDC_TRANSPARENT_SCROLL, CANDOTRANSPARENCY(Type) );
ControlEnable( hDlg, IDC_TRANSPARENT, CANDOTRANSPARENCY(Type) );
}
LOCAL void Vignette_HandleEnable(HWND hDlg, int fFlags)
/************************************************************************/
{
FRMDATATYPE Type = FDT_RGBCOLOR;
ImgGetInfo(GetActiveImage(), NULL, NULL, NULL, &Type);
HandleMergeCombo(hDlg, IDC_MERGEMODE, TRUE, Vignette.VigMergeMode, 0L);
// The following code also goes below and into the shape accelerator
ControlEnableGroup( hDlg, IDC_FIRST_MODEL, IDC_LAST_MODEL, ISCOLOR(Type));
ControlEnable( hDlg, IDC_COLORMODEL, ISCOLOR(Type));
ControlEnable( hDlg, IDC_TRANSPARENT, CANDOTRANSPARENCY(Type) );
}
BOOL HueImage(LPIMAGE lpImage, LPHUE_PARMS lpParms)
/************************************************************************/
{
LPMAPS lpMaps;
RECT rUpdate;
UPDATE_TYPE UpdateType;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART || type == FDT_GRAYSCALE)
return(FALSE);
else if (type == FDT_PALETTECOLOR && ImgGetMask(lpImage))
return(FALSE);
if (!(lpMaps = (LPMAPS)Alloc((long)sizeof(MAPS))))
{
lpParms->Common.StatusCode = SC_MEMERROR;
Message(IDS_EMEMALLOC);
return(FALSE);
}
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
ResetMap( &lpMaps->MasterMap, MAXPOINTS, NO );
ResetMap( &lpMaps->RedMap, MAXPOINTS, NO );
ResetMap( &lpMaps->GreenMap, MAXPOINTS, NO );
ResetMap( &lpMaps->BlueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->BlackMap, MAXPOINTS, NO );
ResetMap( &lpMaps->HueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->SatMap, MAXPOINTS, NO );
lpMaps->HueMap.Points = lpParms->HueInfo.Points;
copy((LPTR)&lpParms->HueInfo.Pnt, (LPTR)&lpMaps->HueMap.Pnt, sizeof(lpMaps->HueMap.Pnt));
lpMaps->SatMap.Brightness[0] = lpParms->Saturation;
lpMaps->MasterMap.Brightness[0] = lpParms->Brightness;
MakeMap(&lpMaps->HueMap);
MakeMap(&lpMaps->SatMap);
MakeMap(&lpMaps->MasterMap);
lpParms->Common.StatusCode = ApplyMaps(lpImage, lpMaps, lpParms->Common.idDirty, &rUpdate, &UpdateType);
if (UpdateType)
{
lpParms->Common.UpdateType = UpdateType;
lpParms->Common.rUpdateArea = rUpdate;
}
FreeUp(lpMaps);
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
LOCAL void Flood_HandleEnable(HWND hDlg, int fFlags)
/************************************************************************/
{
FRMDATATYPE Type = FDT_RGBCOLOR;
ImgGetInfo(GetActiveImage(), NULL, NULL, NULL, &Type);
HandleMergeCombo(hDlg, IDC_MERGEMODE, TRUE, Fill.FloodMergeMode, 0L);
ControlEnableGroup( hDlg, IDC_FIRST_MODEL, IDC_LAST_MODEL, ISCOLOR(Type));
ControlEnable( hDlg, IDC_COLORMODEL, ISCOLOR(Type));
ControlEnable( hDlg, IDC_FLOODRANGE, Type != FDT_LINEART);
ControlEnable( hDlg, IDC_TRANSPARENT, CANDOTRANSPARENCY(Type));
ControlEnable( hDlg, IDC_FLOODFADE, CANDOTRANSPARENCY(Type));
}
BOOL ContBritImage(LPIMAGE lpImage, LPCONTBRIT_PARMS lpParms)
/************************************************************************/
{
LPMAPS lpMaps;
int i;
RECT rUpdate;
UPDATE_TYPE UpdateType;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
return(FALSE);
else if (type == FDT_PALETTECOLOR && ImgGetMask(lpImage))
return(FALSE);
if (!(lpMaps = (LPMAPS)Alloc((long)sizeof(MAPS))))
{
lpParms->Common.StatusCode = SC_MEMERROR;
Message(IDS_EMEMALLOC);
return(FALSE);
}
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
ResetMapEx( &lpMaps->MasterMap, MAPPOINTS, NO, YES);
ResetMap( &lpMaps->RedMap, MAPPOINTS, NO ); // sometimes Cyan
ResetMap( &lpMaps->GreenMap, MAPPOINTS, NO ); // sometimes Magenta
ResetMap( &lpMaps->BlueMap, MAPPOINTS, NO ); // sometimes Yellow
ResetMap( &lpMaps->BlackMap, MAPPOINTS, NO );
ResetMap( &lpMaps->HueMap, MAXPOINTS, NO );
ResetMap( &lpMaps->SatMap, MAPPOINTS, NO );
lpMaps->MasterMap.Contrast = lpParms->Contrast;
for (i = 0; i < NUM_BANDS; ++i)
lpMaps->MasterMap.Brightness[i] = lpParms->Brightness[i];
MakeMap(&lpMaps->MasterMap);
lpParms->Common.StatusCode = ApplyMaps(lpImage, lpMaps, lpParms->Common.idDirty, &rUpdate, &UpdateType);
if (UpdateType)
{
lpParms->Common.UpdateType = UpdateType;
lpParms->Common.rUpdateArea = rUpdate;
}
FreeUp(lpMaps);
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
BOOL ApplyCalImage(LPIMAGE lpImage, LPAPPLYCAL_PARMS lpParms)
/************************************************************************/
{
RECT rUpdate;
UPDATE_TYPE UpdateType;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
return(FALSE);
else if (type == FDT_PALETTECOLOR && ImgGetMask(lpImage))
return(FALSE);
ProgressBegin(1, lpParms->Common.idDirty-IDS_UNDOFIRST+IDS_PROGFIRST);
lpParms->Common.StatusCode = ApplyCalibration(lpImage, lpParms->Common.idDirty,
lpParms->szScanMap, lpParms->szPrintMap, &rUpdate, &UpdateType);
if (UpdateType)
{
lpParms->Common.UpdateType = UpdateType;
lpParms->Common.rUpdateArea = rUpdate;
}
ProgressEnd();
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
BOOL CSizeImageDlg::DoSizeControls( ITEMID id, UINT codeNotify, BOOL bResAdjust )
{
BOOL bResult = TRUE;
HWND hDlg = GetSafeHwnd();
BOOL Bool;
long x, y;
int npix, nlin;
HWND hWnd, hControl;
RECT rArea;
LFIXED scale;
LPIMAGE lpImage;
FRMDATATYPE Type;
lpImage = GetImage();
ImgGetInfo(lpImage, NULL, NULL, NULL, &Type);
npix = CROPWIDTH();
nlin = CROPHEIGHT();
switch( id )
{
case IDC_SMARTSIZE:
m_SmartSize = !m_SmartSize;
CheckDlgButton( IDC_SMARTSIZE, m_SmartSize );
break;
case IDC_MAINTAINSIZE:
m_MaintainSize = !m_MaintainSize;
if (m_MaintainSize)
m_Distortable = NO;
ControlEnable(hDlg, IDC_DISTORT, !m_MaintainSize);
ControlEnable(hDlg, IDC_SMARTSIZE, !m_MaintainSize);
Bool = !m_MaintainSize || m_Units != IDC_PREF_UNITPIXELS;
ControlEnable(hDlg, IDC_WIDTH, Bool);
ControlEnable(hDlg, IDC_HEIGHT, Bool);
ControlEnable(hDlg, IDC_SCALEX, Bool);
ControlEnable(hDlg, IDC_SCALEY, Bool);
if (m_MaintainSize)
{
m_Resolution = m_CropResolution = m_OrigResolution;
m_Width = FGET( npix, m_CropResolution );
m_Height = FGET( nlin, m_CropResolution );
SetUnitResolution( m_CropResolution );
SetDlgItemSpin( hDlg, IDC_RES, m_Resolution, NO );
SetDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES );
SetDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES );
}
CheckDlgButton( IDC_MAINTAINSIZE, m_MaintainSize );
CheckDlgButton( IDC_SMARTSIZE, !m_MaintainSize && m_SmartSize );
break;
case IDC_PREF_UNITS:
{
WORD wUnits;
if ( !(wUnits = HandleCombo( hDlg, id, codeNotify )) )
break;
m_Units = wUnits;
SetUnitInfo((UNIT_TYPE)(m_Units-IDC_PREF_UNITINCHES), m_UnitRes,
m_Points);
CheckComboItem(hDlg, IDC_PREF_UNITS, IDC_PREF_UNITFIRST,
IDC_PREF_UNITLAST, m_Units);
Bool = !m_MaintainSize || m_Units != IDC_PREF_UNITPIXELS;
ControlEnable(hDlg, IDC_WIDTH, Bool);
ControlEnable(hDlg, IDC_HEIGHT, Bool);
ControlEnable(hDlg, IDC_SCALEX, Bool);
ControlEnable(hDlg, IDC_SCALEY, Bool);
if (m_MaintainSize && m_Units == IDC_PREF_UNITPIXELS)
{
m_CropResolution = m_Resolution;
SetUnitResolution( m_CropResolution );
m_Width = FGET( npix, m_CropResolution );
m_Height = FGET( nlin, m_CropResolution );
y = FMUL( m_CropResolution, m_Height );
m_ScaleY = ((y*100L) + nlin/2) / nlin;
SetDlgItemSpin( hDlg, IDC_SCALEY, m_ScaleY, NO );
x = FMUL( m_CropResolution, m_Width );
m_ScaleX = ((x*100L) + npix/2) / npix;
SetDlgItemSpin( hDlg, IDC_SCALEX, m_ScaleX, NO );
}
SetDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES );
SetDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES );
SetUnitLabels();
}
break;
case IDC_DISTORT:
m_Distortable = !m_Distortable;
CheckDlgButton( IDC_DISTORT, m_Distortable );
if (m_Distortable)
m_MaintainSize = NO;
ControlEnable(hDlg, IDC_MAINTAINSIZE, !m_MaintainSize);
if ( m_ScaleX != m_ScaleY )
{
m_ScaleX = m_ScaleY;
x = (((long)npix * m_ScaleX)+50L)/100L;
m_Width = FGET( x, m_CropResolution );
SetDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES );
SetDlgItemSpin( hDlg, IDC_SCALEX, m_ScaleX, NO );
}
CheckDlgButton( IDC_SMARTSIZE,m_SmartSize && !m_Distortable);
ControlEnable( hDlg, IDC_SMARTSIZE, !m_Distortable && CANDOTRANSPARENCY(Type));
ControlEnable(hDlg, IDC_MAINTAINSIZE, !m_Distortable && lpImage);
if ( Page.PrintNumeric )
break;
if ( !(hWnd = ::GetDlgItem( hDlg,IDC_PRINTVIEWPAGE)) )
break;
if ( !(hControl = ::GetDlgItem( hDlg,IDC_PRINTVIEWIMAGE)) )
break;
SetLongBit(hControl, GWL_STYLE, IS_RATIO_CONSTRAIN,
!m_Distortable );
if (!m_Distortable)
{
::GetWindowRect(hControl, &rArea);
::ScreenToClient(hWnd, (LPPOINT)&rArea.left);
::ScreenToClient(hWnd, (LPPOINT)&rArea.right);
::MoveWindow(hControl, rArea.left, rArea.top,
RectWidth(&rArea)-1, RectHeight(&rArea)-1, TRUE);
}
break;
case IDC_HEIGHT:
if ( ::GetFocus() != ::GetDlgItem( hDlg,id ) )
break;
if ( codeNotify != EN_CHANGE )
break;
m_Height = GetDlgItemSpinFixed( hDlg, IDC_HEIGHT, &Bool, YES);
if (m_MaintainSize)
{
scale = FGET(FUNITY, m_Height);
m_Resolution = FMUL(nlin, scale);
SetUnitResolution( m_Resolution );
SetDlgItemSpin( hDlg, IDC_RES, m_Resolution, NO );
}
// y = number of new pixels x 100
y = FMUL( m_CropResolution, m_Height );
// calculate scale factor = (new pixels * 100) / old pixels
m_ScaleY = ((y * 100L) + nlin/2) / nlin;
SetDlgItemSpin( hDlg, IDC_SCALEY, m_ScaleY, NO );
if ( !m_Distortable )
{
m_ScaleX = m_ScaleY;
x = (((long)npix * (long)y) + (nlin/2))/ (long)nlin;
m_Width = FGET( x, m_CropResolution );
SetDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES );
SetDlgItemSpin( hDlg, IDC_SCALEX, m_ScaleX, NO );
}
ImageMemory( hDlg, IDC_MEMORY,
m_MaintainSize ? FGET(npix,1) : m_Width,
m_MaintainSize ? FGET(nlin,1) : m_Height,
m_MaintainSize ? 1 : m_Resolution, m_Depth );
break;
case IDC_WIDTH:
if ( ::GetFocus() != ::GetDlgItem( hDlg, id ) )
break;
if ( codeNotify != EN_CHANGE )
break;
m_Width = GetDlgItemSpinFixed( hDlg, IDC_WIDTH, &Bool, YES );
if (m_MaintainSize)
{
scale = FGET(FUNITY, m_Width);
m_Resolution = FMUL(npix, scale);
SetUnitResolution( m_Resolution );
SetDlgItemSpin( hDlg, IDC_RES, m_Resolution, NO );
}
x = FMUL( m_CropResolution, m_Width );
m_ScaleX = ((x * 100L) + npix/2L) / (long)npix;
SetDlgItemSpin( hDlg, IDC_SCALEX, m_ScaleX, NO );
if ( !m_Distortable )
{
m_ScaleY = m_ScaleX;
y = (((long)nlin * (long)x) + (npix/2))/ (long)npix;
m_Height = FGET( y, m_CropResolution );
SetDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES );
SetDlgItemSpin( hDlg, IDC_SCALEY, m_ScaleY, NO );
}
ImageMemory( hDlg, IDC_MEMORY,
m_MaintainSize ? FGET(npix,1) : m_Width,
m_MaintainSize ? FGET(nlin,1) : m_Height,
m_MaintainSize ? 1 : m_Resolution, m_Depth );
break;
case IDC_RES:
if ( ::GetFocus() != ::GetDlgItem( hDlg, id ) )
break;
if ( codeNotify != EN_CHANGE )
break;
m_Resolution = GetDlgItemSpin( hDlg, IDC_RES, &Bool, NO );
if ( m_Resolution <= 0 )
m_Resolution = 2;
if (m_MaintainSize)
{
m_Width = FGET(npix, m_Resolution);
m_Height = FGET(nlin, m_Resolution);
SetUnitResolution( m_Resolution );
if (m_Units != IDC_PREF_UNITPIXELS)
{
SetDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES );
SetDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES );
y = FMUL( m_CropResolution, m_Height );
m_ScaleY = ((y*100L) + nlin/2) / nlin;
SetDlgItemSpin( hDlg, IDC_SCALEY, m_ScaleY, NO );
x = FMUL( m_CropResolution, m_Width );
m_ScaleX = ((x*100L) + npix/2) / npix;
SetDlgItemSpin( hDlg, IDC_SCALEX, m_ScaleX, NO );
}
}
if ( m_Units == IDC_PREF_UNITPIXELS )
{
if ( bResAdjust )
{ // Extract the values again (inch values changed)
m_CropResolution = m_Resolution;
SetUnitResolution( m_Resolution );
::SetFocus( hWnd = ::GetDlgItem( hDlg,IDC_HEIGHT ) );
FORWARD_WM_COMMAND(hDlg, IDC_HEIGHT, hWnd, EN_CHANGE,
::SendMessage);
::SetFocus( hWnd = ::GetDlgItem( hDlg,IDC_WIDTH ) );
FORWARD_WM_COMMAND(hDlg, IDC_WIDTH, hWnd, EN_CHANGE,
::SendMessage);
::SetFocus( ::GetDlgItem( hDlg,id ) );
}
else
{ // Change the edit box
SetUnitResolution( m_Resolution );
SetDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES);
SetDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES );
}
}
ImageMemory( hDlg, IDC_MEMORY,
m_MaintainSize ? FGET(npix,1) : m_Width,
m_MaintainSize ? FGET(nlin,1) : m_Height,
m_MaintainSize ? 1 : m_Resolution, m_Depth );
break;
case IDC_SCALEX:
if ( GetFocus() != GetDlgItem( id ) )
break;
if ( codeNotify != EN_CHANGE )
break;
m_ScaleX = GetDlgItemSpin( hDlg, IDC_SCALEX, &Bool, NO );
x = (((long)npix * m_ScaleX)+50L)/100L;
m_Width = FGET( x, m_CropResolution );
SetDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES );
if (m_MaintainSize)
{
scale = FGET(FUNITY, m_Width);
m_Resolution = FMUL(npix, scale);
SetUnitResolution( m_Resolution );
SetDlgItemSpin( hDlg, IDC_RES, m_Resolution, NO );
}
if ( !m_Distortable )
{
m_ScaleY = m_ScaleX;
y = (((long)nlin * m_ScaleY)+50)/100L;
m_Height = FGET( y, m_CropResolution );
SetDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES );
SetDlgItemSpin( hDlg, IDC_SCALEY, m_ScaleY, NO );
}
ImageMemory( hDlg, IDC_MEMORY,
m_MaintainSize ? FGET(npix,1) : m_Width,
m_MaintainSize ? FGET(nlin,1) : m_Height,
m_MaintainSize ? 1 : m_Resolution, m_Depth );
break;
case IDC_SCALEY:
if ( GetFocus() != GetDlgItem( id ) )
break;
if ( codeNotify != EN_CHANGE )
break;
m_ScaleY = GetDlgItemSpin( hDlg, IDC_SCALEY, &Bool, NO );
y = (((long)nlin * m_ScaleY)+50)/100L;
m_Height = FGET( y, m_CropResolution );
SetDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES );
if (m_MaintainSize)
{
scale = FGET(FUNITY, m_Height);
m_Resolution = FMUL(nlin, scale);
SetUnitResolution( m_Resolution );
SetDlgItemSpin( hDlg, IDC_RES, m_Resolution, NO );
}
if ( !m_Distortable )
{
m_ScaleX = m_ScaleY;
x = (((long)npix * m_ScaleX)+50L)/100L;
m_Width = FGET( x, m_CropResolution );
SetDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES);
SetDlgItemSpin( hDlg, IDC_SCALEX, m_ScaleX, NO );
}
ImageMemory( hDlg, IDC_MEMORY,
m_MaintainSize ? FGET(npix,1) : m_Width,
m_MaintainSize ? FGET(nlin,1) : m_Height,
m_MaintainSize ? 1 : m_Resolution, m_Depth );
break;
case IDC_MEMORY:
default:
bResult = FALSE;
break;
}
return bResult;
}
void VignetteProc( HWND hWindow, UINT msg, int x, int y, UINT32 Option )
/************************************************************************/
{
RECT Rect;
BOOL fShift;
POINT pt;
static int Type, Style;
static BOOL fConstrain;
static RECT SelectRect;
int res;
FRMDATATYPE type;
LPIMAGE lpImage;
STRING szString;
GRADIENT_PARMS parms;
switch (msg)
{
case WM_CREATE: // The first mouse down message
if (!IsOnImage(hWindow, x, y))
break;
ImgGetInfo(GetActiveImage(), NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
{
AstralStrEx( IDC_TOOLNAMESTART+IDC_VIGNETTE, szString, sizeof(szString) );
Message(IDS_NOTWITHLINEART, (LPSTR)szString);
break;
}
AstralUpdateWindow(hWindow);
Tool.bActive = YES;
// SetMaskingState( x, y );
break;
case WM_LBUTTONDOWN:
Type = Vignette.Gradient;
fConstrain = ( Type == IDC_VIGSQUARE || Type == IDC_VIGCIRCLE );
AstralSetRectEmpty( &SelectRect );
if ( Type == IDC_VIGCIRCLE || Type == IDC_VIGELLIPSE )
Style = SL_ELLIPSE;
else
if ( Type == IDC_VIGRADIAL || Type == IDC_VIGLINEAR )
Style = SL_LINE;
else
Style = SL_BOX;
pt.x = x; pt.y = y;
StartSelection( hWindow, NULL, &SelectRect, Style | SL_SPECIAL,
pt, 0L );
break;
case WM_LBUTTONUP:
Tool.bActive = NO;
Rect = SelectRect; // make a copy before it gets ordered
EndSelection( hWindow, NULL, &SelectRect, Style, YES );
lpImage = (LPIMAGE)GetImagePtr ( hWindow );
res = FrameResolution(ImgGetBaseEditFrame(lpImage));
type = FrameType(ImgGetBaseEditFrame(lpImage));
parms.VigOpacity = Vignette.VigOpacity;
parms.VigMergeMode = Vignette.VigMergeMode;
parms.iBaseRes = res;
parms.x1 = Rect.left;
parms.y1 = Rect.top;
parms.x2 = Rect.right;
parms.y2 = Rect.bottom;
GetActiveColorFromType(type, &parms.StartColor);
GetAlternateColorFromType(type, &parms.EndColor);
parms.Gradient = Vignette.Gradient;
parms.RepeatCount = Vignette.RepeatCount;
parms.SoftTransition = Vignette.SoftTransition;
parms.Midpoint = Vignette.Midpoint;
parms.VigColorModel = Vignette.VigColorModel;
ProcessCommand(lpImage->lpCmdList, IDS_CMD_GRADIENT, &parms);
break;
case WM_MOUSEMOVE: // sent when ToolActive is on
fShift = SHIFT;
pt.x = x; pt.y = y;
UpdateSelection( hWindow, NULL, &SelectRect, Style,
pt, fConstrain^CONSTRAINASPECT, 1L, 1L,
MOVEKEY||Window.fRButtonDown, FROMCENTER);
break;
case WM_LBUTTONDBLCLK:
break;
case WM_DESTROY: // The cancel operation message
if (!Tool.bActive)
break;
Tool.bActive = NO;
EndSelection( hWindow, NULL, &SelectRect, Style, YES );
break;
}
}
BOOL GradientImage( LPIMAGE lpImage, LPGRADIENT_PARMS lpParms)
{
LPFRAME lpFrame;
RECT rMask;
LPINT lpD;
FRMTYPEINFO TypeInfo;
int dx, dy, iCount;
int index, prev, next, pi, ni;
long ldx, ldy, x, y, xs, xe, ys, ye, asqrd, bsqrd, r;
LPDATAPROC lpVignetteProc;
ENGINE Engine;
BOOL DoHSL;
GRADIENT_DATA data;
int res;
FRMDATATYPE type;
ImgGetInfo(lpImage, NULL, NULL, NULL, &type);
if (type == FDT_LINEART)
return(FALSE);
if (!(lpFrame = ImgGetBaseEditFrame(lpImage)))
return(FALSE);
res = FrameResolution(lpFrame);
data.x1 = lpParms->x1;
data.y1 = lpParms->y1;
data.x2 = lpParms->x2;
data.y2 = lpParms->y2;
ResConvertUL(lpParms->iBaseRes, res, &data.x1, &data.y1);
ResConvertLR(lpParms->iBaseRes, res, &data.x2, &data.y2);
dx = data.x2 - data.x1;
dy = data.y2 - data.y1;
data.SoftTransition = lpParms->SoftTransition;
data.lpPaletteLUT = NULL;
if (lpParms->Gradient == IDC_VIGLINEAR || lpParms->Gradient == IDC_VIGRADIAL)
{
if (abs(dx) <= 3 && abs(dy) <= 3)
return(FALSE);
}
else
{
if (abs(dx) <= 3 || abs(dy) <= 3)
return(FALSE);
}
data.xc = (data.x1 + data.x2) / 2;
data.yc = (data.y1 + data.y2) / 2;
if ( (data.nRepetitions = lpParms->RepeatCount) <= 0 )
data.nRepetitions = 1;
FrameGetTypeInfo(lpFrame, &TypeInfo);
DoHSL = (lpParms->VigColorModel+IDC_FIRST_MODEL) != IDC_MODEL_RGB &&
(TypeInfo.DataType > FDT_GRAYSCALE);
switch (lpParms->Gradient)
{
case IDC_VIGLINEAR:
data.D = lsqrt(((long)dx*(long)dx)+((long)dy*(long)dy));
data.sine = FGET(-dy, data.D);
data.cosine = FGET(dx, data.D);
data.xr = WHOLE(( rotx(data.x2, data.y2, data.x1, data.y1,
data.cosine, data.sine) ));
lpVignetteProc = (LPDATAPROC)linear_vignette_proc;
break;
case IDC_VIGRADIAL:
data.D = lsqrt(((long)dx*(long)dx)+((long)dy*(long)dy));
lpVignetteProc = (LPDATAPROC)radial_vignette_proc;
break;
case IDC_VIGCIRCLE:
data.x1 = data.xc;
data.y1 = data.yc;
data.y2 = data.yc;
dx = data.x2 - data.x1;
dy = data.y2 - data.y1;
if (!dx && !dy)
return(FALSE);
data.D = lsqrt(((long)dx*(long)dx)+((long)dy*(long)dy));
lpVignetteProc = (LPDATAPROC)radial_vignette_proc;
break;
case IDC_VIGSQUARE:
case IDC_VIGRECTANGLE:
data.ymin = min(data.y1, data.y2);
data.ymax = max(data.y1, data.y2);
data.xmin = min(data.x1, data.x2);
data.xmax = max(data.x1, data.x2);
ldx = data.xmin-data.xc; // upper left
ldy = data.ymin-data.yc;
data.m1 = (256L * ldy) / ldx;
data.b1 = data.ymin - ((data.m1 * data.xmin)/256L);
data.D1 = lsqrt((ldx*ldx)+(ldy*ldy));
ldx = data.xmax-data.xc; // upper right
ldy = data.ymin-data.yc;
data.m2 = (256L * ldy) / ldx;
data.b2 = data.ymin - ((data.m2 * data.xmax)/256L);
data.D2 = lsqrt((ldx*ldx)+(ldy*ldy));
ldx = data.xmax-data.xc; // lower right
ldy = data.ymax-data.yc;
data.m3 = (256L * ldy) / ldx;
data.b3 = data.ymax - ((data.m3 * data.xmax)/256L);
data.D3 = lsqrt((ldx*ldx)+(ldy*ldy));
ldx = data.xmin-data.xc; // lower left
ldy = data.ymax-data.yc;
data.m4 = (256L * ldy) / ldx;
data.b4 = data.ymax - ((data.m4 * data.xmin)/256L);
data.D4 = lsqrt((ldx*ldx)+(ldy*ldy));
lpVignetteProc = (LPDATAPROC)rectangle_vignette_proc;
break;
case IDC_VIGELLIPSE:
if ( !(data.lpD = (LPINT)Alloc((long)sizeof(int)*(TSIZE+1))) )
{
Message(IDS_EMEMALLOC);
return(FALSE);
}
iCount = TSIZE+1;
lpD = data.lpD;
while (--iCount >= 0)
*lpD++ = -1;
data.ymin = min(data.y1, data.y2);
data.ymax = max(data.y1, data.y2);
data.xmin = min(data.x1, data.x2);
data.xmax = max(data.x1, data.x2);
data.ea = dx/2;
data.eb = dy/2;
if (!data.ea || !data.eb)
{
FreeUp((LPTR)data.lpD);
return(FALSE);
}
asqrd = data.ea*data.ea;
bsqrd = data.eb*data.eb;
// fill in a table with radius information for the
// ellipse. The radius for a given point would be
// starting from the center of the ellipse, going
// through to point, and where it intersects the
// edge of the ellipse. We need the radius for
// the D value used in the ellipse_proc, which is
// the maximum distance used for determining how to
// calculate the gradient, which is d/D. d is the
// distance of the point from the center, D is extracted
// from the table built below. The index of the table is
// formed from the ratio of sides of the triangle formed.
// This is like looking up the angle to see where the
// point would intersect the circle. But we calculate
// the radii ahead of time to speed things up.
if (data.ea > data.eb) // step in x
{
xs = data.xc - data.xc;
xe = data.xmax - data.xc;
for (x = xs; x <= xe; ++x)
{
y = ((data.eb*(long)lsqrt(asqrd - (x*x)))+(data.ea/2))/data.ea;
r = (x*x)+(y*y);
if (r <= 0)
r = 1;
index = ((x * x * (long)TSIZE)+(r/2)) / r;
index = bound(abs(index), 0, TSIZE);
data.lpD[index] = lsqrt(r);
}
}
else // step in y
{
ys = data.yc - data.yc;
ye = data.ymax - data.yc;
for (y = ys; y <= ye; ++y)
{
x = ((data.ea*(long)lsqrt(bsqrd - (y*y)))+(data.eb/2))/data.eb;
r = (x*x)+(y*y);
if (r <= 0)
r = 1;
index = ((y * y * (long)TSIZE)+(r/2)) / r;
index = bound(abs(index), 0, TSIZE);
data.lpD[index] = lsqrt(r);
}
}
// find the first valid entry in our table
for (index = 0; index <= TSIZE && data.lpD[index] < 0; ++index)
;
// see if we have any entries
if (index > TSIZE)
{
FreeUp((LPTR)data.lpD);
return(FALSE);
}
// fill in all entries before first with value of first
while (--index >= 0)
data.lpD[index] = data.lpD[index+1];
// find last valid entry in table
for (index = TSIZE; index >= 0 && data.lpD[index] < 0; --index)
;
// see if we have any entries
if (index < 0)
{
FreeUp((LPTR)data.lpD);
return(FALSE);
}
// fill in all entries after last with value of last
while (++index <= TSIZE)
data.lpD[index] = data.lpD[index-1];
// interpolate values of all empty cells
for (index = 0; index <= TSIZE; ++index)
{
if (data.lpD[index] < 0)
{
pi = index - 1;
prev = data.lpD[pi];
ni = index;
while (data.lpD[ni] < 0)
++ni;
next = data.lpD[ni];
// remember here that (index-pi) == 1
data.lpD[index] = prev + ((next-prev)/(ni-pi));
}
}
lpVignetteProc = (LPDATAPROC)ellipse_vignette_proc;
break;
default:
return(FALSE);
break;
}
switch(TypeInfo.DataType)
{
case FDT_LINEART :
case FDT_GRAYSCALE :
data.lpProcessProc = (LPVIGPROC)ProcessVignette8;
break;
case FDT_PALETTECOLOR:
data.lpProcessProc = (LPVIGPROC)ProcessVignette8P;
data.lpPaletteLUT = CreatePaletteLut15(TypeInfo.ColorMap->RGBData,
TypeInfo.ColorMap->NumEntries, NULL, NULL);
break;
case FDT_RGBCOLOR :
data.lpProcessProc = (LPVIGPROC)ProcessVignette24;
break;
case FDT_CMYKCOLOR :
data.lpProcessProc = (LPVIGPROC)ProcessVignette32;
break;
}
data.lpMidpointTable = BuildMidPointTable(
DoHSL,
TypeInfo.DataType,
lpParms->Midpoint,
&lpParms->StartColor,
&lpParms->EndColor,
&data );
ImgGetMaskRect( lpImage, &rMask );
data.lplD = (LPLONG)Alloc((long)sizeof(long)*(long)RectWidth(&rMask));
data.lpld = (LPLONG)Alloc((long)sizeof(long)*(long)RectWidth(&rMask));
if (!data.lpld || !data.lplD || !data.lpMidpointTable ||
(TypeInfo.DataType == FDT_PALETTECOLOR && !data.lpPaletteLUT))
{
if (lpParms->Gradient == IDC_VIGELLIPSE)
FreeUp((LPTR)data.lpD);
if (data.lplD)
FreeUp((LPTR)data.lplD);
if (data.lpld)
FreeUp((LPTR)data.lpld);
if (data.lpMidpointTable)
FreeUp((LPTR)data.lpMidpointTable);
if (data.lpPaletteLUT)
FreeUp(data.lpPaletteLUT);
return(FALSE);
}
SetEngineDraw(&Engine,lpVignetteProc,lpParms->VigOpacity,lpParms->VigMergeMode);
Engine.lpParam = &data;
Engine.fThread = NO;
lpParms->Common.StatusCode = LineEngineSelObj(lpImage,&Engine,lpParms->Common.idDirty);
if (!AstralIsRectEmpty(&Engine.rUpdate))
{
lpParms->Common.UpdateType = UT_AREA;
lpParms->Common.rUpdateArea = Engine.rUpdate;
}
FreeUp((LPTR)data.lpld);
FreeUp((LPTR)data.lplD);
FreeUp((LPTR)data.lpMidpointTable);
if (data.lpPaletteLUT)
FreeUp(data.lpPaletteLUT);
if (lpParms->Gradient == IDC_VIGELLIPSE)
FreeUp((LPTR)data.lpD);
return(lpParms->Common.StatusCode == SC_SUCCESS);
}
