/*
 * @(#) grspec.cpp - Graphic special effects program for Windows.
 * (c) 1996 Ivan Maidanski <ivmai@chat.ru> http://ivmai.chat.ru
 * Freeware program source. All rights reserved.
 **
 * Language: C++
 * Tested with: Borland C++ v3.1
 * Last modified: 1996-05-01 08:15:00 GMT+04:00
 */

// Resource file: grspec.rc

#define WIN31
#define STRICT

#include <owl.h>
#include <windobj.h>
#include <string.h>

const int BitMapWidth= 800;
const int BitMapHeight= 600;

const COLORREF Colors[3][16]=
 {{0x00FFFFFFl,0x00E0E0E0l,0x00C0C0FFl,0x00C0E0FFl,
   0x00E0FFFFl,0x00C0FFC0l,0x00FFFFC0l,0x00FFC0C0l,
   0x00FFC0FFl,0x000000C0l,0x000040C0l,0x0000C0C0l,
   0x0000C000l,0x00C0C000l,0x00C00000l,0x00C000C0l},
  {0x00C0C0C0l,0x00404040l,0x008080FFl,0x0080C0FFl,
   0x0080FFFFl,0x0080FF80l,0x00FFFF80l,0x00FF8080l,
   0x00FF80FFl,0x00000080l,0x00004080l,0x00008080l,
   0x00008000l,0x00808000l,0x00800000l,0x00800080l},
  {0x00808080l,0x00000000l,0x000000FFl,0x000080FFl,
   0x0000FFFFl,0x0000FF00l,0x00FFFF00l,0x00FF0000l,
   0x00FF00FFl,0x00000040l,0x00404080l,0x00004040l,
   0x00004000l,0x00404000l,0x00400000l,0x00400040l}};

const int ToolCount= 8;
const int MenuCount= 13;
const int LineWidthCount= 8;
const int LineStyleCount= 5;
const int IconSize= 32;
const int LineWidth[LineWidthCount]= {1,2,3,4,5,7,9,12};
const int LineStyle[LineStyleCount]=
{ PS_SOLID,PS_DASH,PS_DOT,PS_DASHDOT,PS_DASHDOTDOT };

_CLASSDEF(TDrawTool)

struct TState
{
 PTDrawTool DrawTool;
 HBITMAP BitMap;
 RECT Area;
 int PenWidth,PenStyle;
 COLORREF Foreground,Background;
 int EffectLevel; /* 0%..100% */
};
typedef TState* PTState;

// already _CLASSDEF'ed
class TDrawTool
{
 public:
  TDrawTool(LPSTR IconName,PTState AState);
  virtual ~TDrawTool() { DestroyCursor(Cursor); DestroyIcon(Icon); };
  BOOL MouseDown(HWND AWindow,int X,int Y,COLORREF Color);
  void MouseMove(int X,int Y) { DrawTo(X,Y); };
  void MouseUp();
  virtual BOOL DrawBegin(int X,int Y) { return (FALSE); };
  virtual void DrawTo(int X,int Y) {};
  virtual void DrawEnd() {};
  virtual void Done() {};
  HCURSOR GetCursor() { return (Cursor); };
  HICON GetIcon() { return (Icon); };
 protected:
  HCURSOR Cursor;
  HICON Icon;
  PTState State;
  HWND Window;
  HDC DC;
  HPEN Pen;
  HBRUSH Brush;
};

_CLASSDEF(TPenTool)
class TPenTool : public TDrawTool
{
 public:
  TPenTool(LPSTR IconName,PTState AState)
          : TDrawTool(IconName,AState) {};
  virtual BOOL DrawBegin(int X,int Y);
  virtual void DrawTo(int X,int Y) { LineTo(DC,X,Y); };
};

_CLASSDEF(TFillTool)
class TFillTool : public TDrawTool
{
 public:
  TFillTool(LPSTR IconName,PTState AState)
           : TDrawTool(IconName,AState) {};
  virtual BOOL DrawBegin(int X,int Y);
};

_CLASSDEF(TBoxTool)
class TBoxTool : public TDrawTool
{
 public:
  TBoxTool(LPSTR IconName,PTState AState,BOOL AFilled)
          : TDrawTool(IconName,AState) { Filled=AFilled; };
  virtual BOOL DrawBegin(int X,int Y);
  virtual void DrawTo(int X,int Y);
  virtual void DrawEnd();
 protected:
  virtual void DrawObject(BOOL Draw) {};
 protected:
  BOOL Filled;
  int X1,Y1,X2,Y2;
};

_CLASSDEF(TLineTool)
class TLineTool : public TBoxTool
{
 public:
  TLineTool(LPSTR IconName,PTState AState)
           : TBoxTool(IconName,AState,FALSE) {};
 protected:
  virtual void DrawObject(BOOL) { MoveTo(DC,X1,Y1); LineTo(DC,X2,Y2); };
};

_CLASSDEF(TRectTool)
class TRectTool : public TBoxTool
{
 public:
  TRectTool(LPSTR IconName,PTState AState,BOOL AFilled)
           : TBoxTool(IconName,AState,AFilled) {};
 protected:
  virtual void DrawObject(BOOL) { Rectangle(DC,X1,Y1,X2,Y2); };
};

_CLASSDEF(TEllipseTool)
class TEllipseTool : public TBoxTool
{
 public:
  TEllipseTool(LPSTR IconName,PTState AState,BOOL AFilled)
              : TBoxTool(IconName,AState,AFilled) {};
 protected:
  virtual void DrawObject(BOOL) { Ellipse(DC,X1,Y1,X2,Y2); };
};

_CLASSDEF(TSelectTool)
class TSelectTool : public TRectTool
{
 public:
  TSelectTool(LPSTR IconName,PTState AState)
             : TRectTool(IconName,AState,FALSE) { Selected=FALSE; };
  virtual BOOL DrawBegin(int X,int Y);
  virtual void DrawEnd();
  virtual void Done();
 private:
  virtual void DrawObject(BOOL Draw);
  void DrawFrame(BOOL Draw);
  void CreateRegion();
  void CopyRegion();
  void RestoreRegion();
 private:
  BOOL Selected;
  HBITMAP Region;
};

_CLASSDEF(TPalette)
class TPalette : public TWindow
{
 public:
  TPalette(PTWindowsObject AParent,PTState AState)
          : TWindow(AParent,NULL)
  { Attr.Style=WS_CHILD | WS_VISIBLE; State=AState; };
  virtual void Paint(HDC PaintDC,PAINTSTRUCT& PaintInfo);
  virtual void WMLButtonDown(TMessage& Message)= [WM_FIRST+WM_LBUTTONDOWN]
  { SelectColor(Message,State->Foreground); };
  virtual void WMRButtonDown(TMessage& Message)= [WM_FIRST+WM_RBUTTONDOWN]
  { SelectColor(Message,State->Background); };
 private:
  void SelectColor(TMessage& Message,COLORREF& Color);
 private:
  PTState State;
};

_CLASSDEF(TToolBar)
class TToolBar : public TWindow
{
 public:
  TToolBar(PTWindowsObject AParent,PTState AState);
  virtual ~TToolBar();
  virtual void Paint(HDC PaintDC,PAINTSTRUCT& PaintInfo);
  virtual void WMLButtonDown(TMessage& Message)= [WM_FIRST+WM_LBUTTONDOWN];
 private:
  PTState State;
  PTDrawTool Tools[ToolCount];
};

_CLASSDEF(TLineBar)
class TLineBar : public TWindow
{
 public:
  TLineBar(PTWindowsObject AParent,PTState AState,int ACount)
          : TWindow(AParent,NULL) { LineCount=ACount; State=AState;
   Attr.Style=WS_BORDER | WS_CHILD | WS_VISIBLE; Choice=0; };
  virtual void Paint(HDC PaintDC, PAINTSTRUCT& PaintInfo);
  virtual void WMLButtonDown(TMessage& Message)= [WM_FIRST+WM_LBUTTONDOWN] {};
  int GetBarWidth();
 protected:
  void SelectLine(TMessage& Message);
  virtual int GetLineWidth(int LineNo) { return (1); };
 private:
  virtual void DrawLine(HDC PaintDC,int X,int LineNo) {};
  void Notch(HDC PaintDC,int X,int Y,BOOL Dir,int LineNo);
 protected:
  PTState State;
  int Choice;
 private:
  int LineCount;
};

_CLASSDEF(TLineWidthBar)
class TLineWidthBar : public TLineBar
{
 public:
  TLineWidthBar(PTWindowsObject AParent,PTState AState)
               : TLineBar(AParent,AState,LineWidthCount) {};
  virtual void WMLButtonDown(TMessage& Message)= [WM_FIRST+WM_LBUTTONDOWN]
  { SelectLine(Message); State->PenWidth=LineWidth[Choice]; };
 private:
  virtual void DrawLine(HDC PaintDC,int X,int LineNo);
  virtual int GetLineWidth(int LineNo) { return (LineWidth[LineNo]); };
};

_CLASSDEF(TLineStyleBar)
class TLineStyleBar : public TLineBar
{
 public:
  TLineStyleBar(PTWindowsObject AParent,PTState AState)
               : TLineBar(AParent,AState,LineStyleCount) {};
  virtual void WMLButtonDown(TMessage& Message)= [WM_FIRST+WM_LBUTTONDOWN]
  { SelectLine(Message); State->PenStyle=LineStyle[Choice]; };
 private:
  virtual void DrawLine(HDC PaintDC,int X,int LineNo);
};

_CLASSDEF(TPercentageBar)
class TPercentageBar : public TWindow
{
 public:
  TPercentageBar(PTWindowsObject AParent,int* AValue)
           : TWindow(AParent,NULL)
  { Attr.Style=WS_BORDER | WS_CHILD | WS_VISIBLE; PValue=AValue; };
  virtual void Paint(HDC PaintDC, PAINTSTRUCT& PaintInfo);
  virtual void WMLButtonDown(TMessage& Message)= [WM_FIRST+WM_LBUTTONDOWN];
 private:
  void Notch(HDC PaintDC,int X,int Y);
 private:
  int* PValue;
};

_CLASSDEF(TCanvas)
class TCanvas : public TWindow
{
 public:
  TCanvas(PTWindowsObject AParent,PTState AState);
  virtual ~TCanvas() { DeleteObject(State->BitMap); };
  virtual LPSTR GetClassName() { return ("TCanvas"); };
  virtual void Paint(HDC PaintDC,PAINTSTRUCT& PaintInfo);
  virtual void WMLButtonDown(TMessage& Message)= [WM_FIRST+WM_LBUTTONDOWN]
  { ButtonDown(Message,State->Foreground); };
  virtual void WMRButtonDown(TMessage& Message)= [WM_FIRST+WM_RBUTTONDOWN]
  { ButtonDown(Message,State->Background); };
  virtual void WMLButtonUp(TMessage& Message)= [WM_FIRST+WM_LBUTTONUP];
  virtual void WMRButtonUp(TMessage& Message)= [WM_FIRST+WM_RBUTTONUP]
  { WMLButtonUp(Message); };
  virtual void WMMouseMove(TMessage& Message)= [WM_FIRST+WM_MOUSEMOVE];
  virtual void WMSetCursor(TMessage& Message)= [WM_FIRST+WM_SETCURSOR]
  { SetCursor(State->DrawTool->GetCursor()); };
 private:
  void ButtonDown(TMessage& Message,COLORREF Color);
  void SaveDC();
 private:
  PTState State;
  BOOL Drawing;
};

_CLASSDEF(TMenuItem)
class TMenuItem
{
 public:
  TMenuItem(LPSTR IconName)
  { Icon=LoadIcon(GetApplicationObject()->hInstance,IconName); };
  virtual ~TMenuItem() { DestroyIcon(Icon); };
  virtual void Run(PTState State,HWND CanvasWindow) {};
  HICON GetIcon() { return (Icon); };
 private:
  HICON Icon;
};

_CLASSDEF(TClearAll)
class TClearAll : public TMenuItem
{
 public:
  TClearAll(LPSTR IconName) : TMenuItem(IconName) {};
  virtual void Run(PTState State,HWND CanvasWindow);
};

_CLASSDEF(TClipboardRead)
class TClipboardRead : public TMenuItem
{
 public:
  TClipboardRead(LPSTR IconName) : TMenuItem(IconName) {};
  virtual void Run(PTState State,HWND CanvasWindow);
};

_CLASSDEF(TSpecEffect)
class TSpecEffect: public TMenuItem
{
 public:
  TSpecEffect(LPSTR IconName) : TMenuItem(IconName) {};
  virtual void Run(PTState State,HWND CanvasWindow);
 private:
  virtual void Process(HDC Dest,HDC Src,RECT R,int Percent) {};
};

_CLASSDEF(TBlurringEffect)
class TBlurringEffect: public TSpecEffect
{
 public:
  TBlurringEffect(LPSTR IconName) : TSpecEffect(IconName) {};
 private:
  virtual void Process(HDC Dest,HDC Src,RECT R,int Percent);
  int NewValue(int C,int S,int D,int Percent);
};

_CLASSDEF(TSharpeningEffect)
class TSharpeningEffect: public TSpecEffect
{
 public:
  TSharpeningEffect(LPSTR IconName) : TSpecEffect(IconName) {};
 private:
  virtual void Process(HDC Dest,HDC Src,RECT R,int Percent);
  int NewValue(int C,int S,int Percent);
};

_CLASSDEF(TEmbassingEffect)
class TEmbassingEffect: public TSpecEffect
{
 public:
  TEmbassingEffect(LPSTR IconName) : TSpecEffect(IconName) {};
 private:
  virtual void Process(HDC Dest,HDC Src,RECT R,int Percent);
  int NewValue(int C,int LT,int RB,int Percent);
};

_CLASSDEF(TWColoringEffect)
class TWColoringEffect: public TSpecEffect
{
 public:
  TWColoringEffect(LPSTR IconName) : TSpecEffect(IconName) {};
 private:
  virtual void Process(HDC Dest,HDC Src,RECT R,int Percent);
};

_CLASSDEF(TTonalControl)
class TTonalControl: public TSpecEffect
{
 public:
  TTonalControl(LPSTR IconName) : TSpecEffect(IconName) {};
 protected:
  virtual int NewValue(int Value,int Percent);
 private:
  virtual void Process(HDC Dest,HDC Src,RECT R,int Percent);
  virtual COLORREF NewColor(COLORREF Color,int Percent)
  { return (Color); };
};

_CLASSDEF(TMakeNegative)
class TMakeNegative: public TTonalControl
{
 public:
  TMakeNegative(LPSTR IconName) : TTonalControl(IconName) {};
 private:
  virtual COLORREF NewColor(COLORREF Color,int Percent);
};

_CLASSDEF(TControlRed)
class TControlRed: public TTonalControl
{
 public:
  TControlRed(LPSTR IconName) : TTonalControl(IconName) {};
 private:
  virtual COLORREF NewColor(COLORREF Color,int Percent);
};

_CLASSDEF(TControlGreen)
class TControlGreen: public TTonalControl
{
 public:
  TControlGreen(LPSTR IconName) : TTonalControl(IconName) {};
 private:
  virtual COLORREF NewColor(COLORREF Color,int Percent);
};

_CLASSDEF(TControlBlue)
class TControlBlue: public TTonalControl
{
 public:
  TControlBlue(LPSTR IconName) : TTonalControl(IconName) {};
 private:
  virtual COLORREF NewColor(COLORREF Color,int Percent);
};

_CLASSDEF(TControlBrightness)
class TControlBrightness: public TTonalControl
{
 public:
  TControlBrightness(LPSTR IconName) : TTonalControl(IconName) {};
 private:
  virtual COLORREF NewColor(COLORREF Color,int Percent);
  void NormValue(int& Comp,int& Value,int Percent);
};

_CLASSDEF(TControlContrast)
class TControlContrast: public TTonalControl
{
 public:
  TControlContrast(LPSTR IconName) : TTonalControl(IconName) {};
 private:
  virtual COLORREF NewColor(COLORREF Color,int Percent);
};

_CLASSDEF(TControlSaturation)
class TControlSaturation: public TTonalControl
{
 public:
  TControlSaturation(LPSTR IconName) : TTonalControl(IconName) {};
 private:
  virtual COLORREF NewColor(COLORREF Color,int Percent);
};

_CLASSDEF(TMenuBar)
class TMenuBar : public TWindow
{
 public:
  TMenuBar(PTWindowsObject AParent,PTState AState,PTCanvas ACanvas);
  virtual ~TMenuBar();
  virtual void Paint(HDC PaintDC,PAINTSTRUCT& PaintInfo);
  virtual void WMLButtonDown(TMessage& Message)= [WM_FIRST+WM_LBUTTONDOWN];
 private:
  PTState State;
  PTCanvas Canvas;
  PTMenuItem Items[MenuCount];
};

_CLASSDEF(TGraphEffectsWin)
class TGraphEffectsWin : public TWindow
{
 public:
  TGraphEffectsWin(PTWindowsObject AParent,LPSTR ATitle);
  virtual ~TGraphEffectsWin();
  virtual LPSTR GetClassName() { return ("TGraphEffectsWin"); };
  virtual void GetWindowClass(WNDCLASS& WndClass);
  virtual void WMSize(TMessage& Message)= [WM_FIRST+WM_SIZE];
 private:
  TState State;
  PTCanvas Canvas;
  PTPalette Palette;
  PTToolBar ToolBar;
  PTMenuBar MenuBar;
  PTLineWidthBar LineWidthBar;
  PTLineStyleBar LineStyleBar;
  PTPercentageBar PercentageBar;
};

class TGraphEffectsApp : public TApplication
{
 public:
  TGraphEffectsApp(LPSTR name,HINSTANCE hInstance,HINSTANCE hPrevInstance,
                  LPSTR lpCmd,int nCmdShow)
                  : TApplication(name,hInstance,hPrevInstance,lpCmd,nCmdShow) {};
  virtual void InitMainWindow(void)
  { MainWindow=new TGraphEffectsWin(NULL,"Graphic Special Effects"); };
};

void TSpecEffect::Run(PTState State,HWND CanvasWindow)
{
 RECT R;
 GetClientRect(CanvasWindow,&R);
 if (State->Area.left>R.right || State->Area.top>R.bottom)
  return;
 HDC DC=GetDC(CanvasWindow);
 HDC MemDC=CreateCompatibleDC(DC);
 SelectObject(MemDC,State->BitMap);
 R.left=State->Area.left;
 R.top=State->Area.top;
 if (R.right>State->Area.right)
  R.right=State->Area.right;
 if (R.bottom>State->Area.bottom)
  R.bottom=State->Area.bottom;
 Process(DC,MemDC,R,State->EffectLevel);
 BitBlt(MemDC,R.left,R.top,R.right-R.left,R.bottom-R.top,
        DC,R.left,R.top,SRCCOPY);
 DeleteDC(MemDC);
 ReleaseDC(CanvasWindow,DC);
};

void TBlurringEffect::Process(HDC Dest,HDC Src,RECT R,int Percent)
{
 int X,Y;
 COLORREF C[9];
 if (!Percent)
  return;
 for (Y=R.top;Y<R.bottom;Y++)
  for (X=R.left;X<R.right;X++)
  {
   C[0]=GetPixel(Src,X,Y);
   C[1]=GetPixel(Src,X,Y-1);
   C[2]=GetPixel(Src,X+1,Y-1);
   C[3]=GetPixel(Src,X+1,Y);
   C[4]=GetPixel(Src,X+1,Y+1);
   C[5]=GetPixel(Src,X,Y+1);
   C[6]=GetPixel(Src,X-1,Y+1);
   C[7]=GetPixel(Src,X-1,Y);
   C[8]=GetPixel(Src,X-1,Y-1);
   SetPixel(Dest,X,Y,RGB(
            NewValue(GetRValue(C[0]),GetRValue(C[1])+GetRValue(C[3])+
                     GetRValue(C[5])+GetRValue(C[7]),GetRValue(C[2])+
                     GetRValue(C[4])+GetRValue(C[6])+GetRValue(C[8]),
                     Percent),
            NewValue(GetGValue(C[0]),GetGValue(C[1])+GetGValue(C[3])+
                     GetGValue(C[5])+GetGValue(C[7]),GetGValue(C[2])+
                     GetGValue(C[4])+GetGValue(C[6])+GetGValue(C[8]),
                     Percent),
            NewValue(GetBValue(C[0]),GetBValue(C[1])+GetBValue(C[3])+
                     GetBValue(C[5])+GetBValue(C[7]),GetBValue(C[2])+
                     GetBValue(C[4])+GetBValue(C[6])+GetBValue(C[8]),
                     Percent)));
  }
};

int TBlurringEffect::NewValue(int C,int S,int D,int Percent)
{
 long V=(long(S*12+D*8)*Percent/40+C*(125-Percent*2))/125;
 return (V<0? 0 : (V>255? 255 : (int)V));
};

void TSharpeningEffect::Process(HDC Dest,HDC Src,RECT R,int Percent)
{
 int X,Y;
 COLORREF C[5];
 if (!Percent)
  return;
 for (Y=R.top;Y<R.bottom;Y++)
  for (X=R.left;X<R.right;X++)
  {
   C[0]=GetPixel(Src,X,Y);
   C[1]=GetPixel(Src,X,Y-1);
   C[2]=GetPixel(Src,X+1,Y);
   C[3]=GetPixel(Src,X,Y+1);
   C[4]=GetPixel(Src,X-1,Y);
   SetPixel(Dest,X,Y,RGB(
            NewValue(GetRValue(C[0]),GetRValue(C[1])+GetRValue(C[2])+
                     GetRValue(C[3])+GetRValue(C[4]),Percent),
            NewValue(GetGValue(C[0]),GetGValue(C[1])+GetGValue(C[2])+
                     GetGValue(C[3])+GetGValue(C[4]),Percent),
            NewValue(GetBValue(C[0]),GetBValue(C[1])+GetBValue(C[2])+
                     GetBValue(C[3])+GetBValue(C[4]),Percent)));
  }
};

int TSharpeningEffect::NewValue(int C,int S,int Percent)
{
 long V=((long)C*(100-Percent)-(long)S*Percent/5)/10;
 return (V<0? 0 : (V>255? 255 : (int)V));
};

void TEmbassingEffect::Process(HDC Dest,HDC Src,RECT R,int Percent)
{
 int X,Y;
 COLORREF C,LT,RB;
 if (!Percent)
  return;
 for (Y=R.top;Y<R.bottom;Y++)
  for (X=R.left;X<R.right;X++)
  {
   C=GetPixel(Src,X,Y);
   LT=GetPixel(Src,X-1,Y-1);
   RB=GetPixel(Src,X+1,Y+1);
   SetPixel(Dest,X,Y,RGB(
            NewValue(GetRValue(C),GetRValue(LT),GetRValue(RB),Percent),
            NewValue(GetGValue(C),GetGValue(LT),GetGValue(RB),Percent),
            NewValue(GetBValue(C),GetBValue(LT),GetBValue(RB),Percent)));
  }
};

int TEmbassingEffect::NewValue(int C,int LT,int RB,int Percent)
{
 long V=(long(RB-LT+128)*Percent+C*(50-Percent))/50;
 return (V<0? 0 : (V>255? 255 : (int)V));
};

void TWColoringEffect::Process(HDC Dest,HDC Src,RECT R,int)
{
 int X,Y,SX,SY;
 int Max=-1;
 COLORREF C[25];
 for (Y=R.top;Y<R.bottom;Y++)
  for (X=R.left;X<R.right;X++)
  {
   for (SY=-2;SY<=2;SY++)
    for (SX=-2;SX<=2;SX++)
     C[SY*5+SX+12]=GetPixel(Src,X+SX,Y+SY);
   for (SY=0;SY<13;SY++)
   {
    if (Max>=0)
     C[Max]=0;
    Max=0;
    for (SX=0;SX<25;SX++)
     if (C[SX]>C[Max])
      Max=SX;
   }
   SetPixel(Dest,X,Y,C[Max]);
  }
};

void TTonalControl::Process(HDC Dest,HDC Src,RECT R,int Percent)
{
 int X,Y;
 for (Y=R.top;Y<R.bottom;Y++)
  for (X=R.left;X<R.right;X++)
   SetPixel(Dest,X,Y,NewColor(GetPixel(Src,X,Y),Percent));
};

int TTonalControl::NewValue(int Value,int Percent)
{
 return (Percent<=50 ?
         Percent*Value/50 :
         (Percent-50)*(255-Value)/50+Value);
};

COLORREF TMakeNegative::NewColor(COLORREF Color,int)
{
 return (RGB(255-GetRValue(Color),
             255-GetGValue(Color),255-GetBValue(Color)));
};

COLORREF TControlRed::NewColor(COLORREF Color,int Percent)
{
 return (RGB(NewValue(GetRValue(Color),Percent),
             GetGValue(Color),GetBValue(Color)));
};

COLORREF TControlGreen::NewColor(COLORREF Color,int Percent)
{
 return (RGB(GetRValue(Color),
             NewValue(GetGValue(Color),Percent),GetBValue(Color)));
};

COLORREF TControlBlue::NewColor(COLORREF Color,int Percent)
{
 return (RGB(GetRValue(Color),GetGValue(Color),
             NewValue(GetBValue(Color),Percent)));
};

COLORREF TControlBrightness::NewColor(COLORREF Color,int Percent)
{
 int R=GetRValue(Color);
 int G=GetGValue(Color);
 int B=GetBValue(Color);
 int Y=(50*R+39*G+11*B)/100;
 Y=NewValue(Y,Percent)-Y;
 R+=Y;
 G+=Y;
 B+=Y;
 Y=0;
 NormValue(R,Y,50);
 NormValue(G,Y,39);
 NormValue(B,Y,11);
 NormValue(R,Y,50);
 NormValue(G,Y,39);
 return (RGB(R,G,B));
};

void TControlBrightness::NormValue(int& Comp,int& Value,int Percent)
{
 if (Comp>255)
 {
  Value+=(Comp-255)*Percent/100;
  Comp=255;
 }
  else if (Comp<0)
  {
   Value+=Comp*Percent/100;
   Comp=0;
  }
};

COLORREF TControlContrast::NewColor(COLORREF Color,int Percent)
{
 long R=(long)GetRValue(Color)*(Percent+50)/100;
 long G=(long)GetGValue(Color)*(Percent+50)/100;
 long B=(long)GetBValue(Color)*(Percent+50)/100;
 return (RGB((R<255? (int)R : 255),
             (G<255? (int)G : 255),(B<255? (int)B : 255)));
};

COLORREF TControlSaturation::NewColor(COLORREF Color,int Percent)
{
 int R=GetRValue(Color);
 int G=GetGValue(Color);
 int B=GetBValue(Color);
 int Y=(50*R+39*G+11*B)/100;
 return (RGB((R-Y)*Percent/100+Y,
             (G-Y)*Percent/100+Y,(B-Y)*Percent/100+Y));
};

TDrawTool::TDrawTool(LPSTR IconName,PTState AState)
{
 State=AState;
 char Temp[32];
 _fstrcpy(Temp,IconName);
 strncat(Temp,"Tool",sizeof(Temp)-1);
 Icon=LoadIcon(GetApplicationObject()->hInstance,Temp);
 _fstrcpy(Temp,IconName);
 strncat(Temp,"Cursor",sizeof(Temp)-1);
 Cursor=LoadCursor(GetApplicationObject()->hInstance,Temp);
};

BOOL TDrawTool::MouseDown(HWND AWindow,int X,int Y,COLORREF Color)
{
 Window=AWindow;
 SetCapture(Window);
 Pen=CreatePen(State->PenStyle,State->PenWidth,Color);
 Brush=CreateSolidBrush(Color);
 DC=GetDC(Window);
 return (DrawBegin(X,Y));
};

void TDrawTool::MouseUp()
{
 DrawEnd();
 ReleaseCapture();
 DeleteObject(Brush);
 DeleteObject(Pen);
 ReleaseDC(Window,DC);
};

BOOL TPenTool::DrawBegin(int X,int Y)
{
 SelectObject(DC,Pen);
 MoveTo(DC,X,Y);
 return (FALSE);
};

BOOL TFillTool::DrawBegin(int X,int Y)
{
 SelectObject(DC,Brush);
 ExtFloodFill(DC,X,Y,GetPixel(DC,X,Y),FLOODFILLSURFACE);
 return (FALSE);
};

BOOL TBoxTool::DrawBegin(int X,int Y)
{
 X1=X2=X;
 Y1=Y2=Y;
 SelectObject(DC,GetStockObject(BLACK_PEN));
 SelectObject(DC,GetStockObject(NULL_BRUSH));
 SetROP2(DC,R2_NOT);
 DrawObject(TRUE);
 return (FALSE);
};

void TBoxTool::DrawTo(int X,int Y)
{
 DrawObject(FALSE);
 X2=X;
 Y2=Y;
 DrawObject(TRUE);
};

void TBoxTool::DrawEnd()
{
 DrawObject(FALSE);
 SetROP2(DC,R2_COPYPEN);
 SelectObject(DC,Pen);
 if (Filled)
  SelectObject(DC,Brush);
 DrawObject(TRUE);
};

BOOL TSelectTool::DrawBegin(int X,int Y)
{
 DeleteObject(Pen);
 Pen=CreatePen(PS_DOT,1,0);
 DrawFrame(FALSE);
 X1=X2=X;
 Y1=Y2=Y;
 if (Selected &&
     X1>=State->Area.left && X1<State->Area.right &&
     Y1>=State->Area.top && Y1<State->Area.bottom)
  CreateRegion();
  else DrawObject(TRUE);
 return (Selected);
};

void TSelectTool::DrawEnd()
{
 if (Selected &&
     X1>=State->Area.left && X1<State->Area.right &&
     Y1>=State->Area.top && Y1<State->Area.bottom)
 {
  DeleteObject(Region);
  State->Area.left+=X2-X1;
  State->Area.top+=Y2-Y1;
  State->Area.right+=X2-X1;
  State->Area.bottom+=Y2-Y1;
  DrawFrame(TRUE);
  Selected=TRUE;
 }
  else if (X1!=X2 && Y1!=Y2)
  {
   SetRect(&State->Area,((X1<X2)? X1 : X2)+1,((Y1<Y2)? Y1 : Y2)+1,
                        ((X1<X2)? X2 : X1)-1,((Y1<Y2)? Y2 : Y1)-1);
   Selected=TRUE;
  }
   else
   {
    SetRect(&State->Area,0,0,BitMapWidth,BitMapHeight);
    Selected=FALSE;
   }
};

void TSelectTool::DrawObject(BOOL Draw)
{
 if (Selected &&
     X1>=State->Area.left && X1<State->Area.right &&
     Y1>=State->Area.top && Y1<State->Area.bottom)
  if (Draw)
   CopyRegion();
   else RestoreRegion();
  else TRectTool::DrawObject(Draw);
};

void TSelectTool::CreateRegion()
{
 int W=State->Area.right-State->Area.left;
 int H=State->Area.bottom-State->Area.top;
 HDC RegionDC=CreateCompatibleDC(DC);
 Region=CreateCompatibleBitmap(DC,W,H);
 SelectObject(RegionDC,Region);
 BitBlt(RegionDC,0,0,W,H,DC,State->Area.left,State->Area.top,SRCCOPY);
 DeleteDC(RegionDC);
 PatBlt(DC,State->Area.left,State->Area.top,W,H,WHITENESS);
};

void TSelectTool::CopyRegion()
{
 HDC RegionDC=CreateCompatibleDC(DC);
 SelectObject(RegionDC,Region);
 BitBlt(DC,State->Area.left+X2-X1,State->Area.top+Y2-Y1,
        State->Area.right-State->Area.left,
        State->Area.bottom-State->Area.top,RegionDC,0,0,SRCAND);
 DeleteDC(RegionDC);
};

void TSelectTool::RestoreRegion()
{
 int BegX=State->Area.left+X2-X1;
 int BegY=State->Area.top+Y2-Y1;
 HDC MemDC=CreateCompatibleDC(DC);
 SelectObject(MemDC,State->BitMap);
 BitBlt(DC,BegX,BegY,State->Area.right-State->Area.left,
        State->Area.bottom-State->Area.top,MemDC,BegX,BegY,SRCCOPY);
 DeleteDC(MemDC);
};

void TSelectTool::DrawFrame(BOOL Draw)
{
 X1=State->Area.left-1;
 Y1=State->Area.top-1;
 X2=State->Area.right+1;
 Y2=State->Area.bottom+1;
 SelectObject(DC,Pen);
 SelectObject(DC,GetStockObject(NULL_BRUSH));
 SetROP2(DC,R2_XORPEN);
 if (Selected || Draw)
  TRectTool::DrawObject(Draw);
};

void TSelectTool::Done()
{
 if (Selected)
 {
  HDC WinDC=GetDC(Window);
  DC=CreateCompatibleDC(WinDC);
  SelectObject(DC,State->BitMap);
  Pen=CreatePen(PS_DOT,1,0);
  DrawFrame(FALSE);
  DeleteObject(Pen);
  DeleteDC(DC);
  ReleaseDC(Window,WinDC);
  InvalidateRect(Window,NULL,TRUE);
  Selected=FALSE;
 }
};

void TPalette::Paint(HDC PaintDC,PAINTSTRUCT&)
{
 int X,Y,S;
 HPEN Pen;
 HBRUSH Brush;
 RECT R;
 GetClientRect(HWindow,&R);
 S=R.bottom/17;
 for (Y=0;Y<16;Y++)
  for (X=0;X<3;X++)
  {
   Brush=(HBRUSH)SelectObject(PaintDC,CreateSolidBrush(Colors[X][Y]));
   Rectangle(PaintDC,X*S,Y*S,(X+1)*S+1,(Y+1)*S+1);
   DeleteObject(SelectObject(PaintDC,Brush));
  }
 SelectObject(PaintDC,GetStockObject(NULL_BRUSH));
 Rectangle(PaintDC,0,S*16,R.right,R.bottom);
 Pen=(HPEN)SelectObject(PaintDC,CreatePen(PS_SOLID,5,State->Background));
 Brush=(HBRUSH)SelectObject(PaintDC,CreateSolidBrush(State->Foreground));
 Rectangle(PaintDC,3,S*16+3,R.right-3,R.bottom-3);
 DeleteObject(SelectObject(PaintDC,Brush));
 DeleteObject(SelectObject(PaintDC,Pen));
};

void TPalette::SelectColor(TMessage& Message,COLORREF& Color)
{
 int X,Y,S;
 RECT R;
 HDC DC=GetDC(HWindow);
 GetClientRect(HWindow,&R);
 S=R.bottom/17;
 X=Message.LP.Lo/S;
 Y=Message.LP.Hi/S;
 if (X<3 && Y<16)
 {
  Color=GetPixel(DC,X*S+1,Y*S+1);
  InvalidateRect(HWindow,NULL,FALSE);
 }
 ReleaseDC(HWindow,DC);
};

TToolBar::TToolBar(PTWindowsObject AParent,PTState AState)
                  : TWindow(AParent,NULL)
{
 Attr.Style=WS_CHILD | WS_VISIBLE;
 State=AState;
 Tools[0]=new TPenTool("Pen",State);
 Tools[1]=new TLineTool("Line",State);
 Tools[2]=new TRectTool("Rect",State,FALSE);
 Tools[3]=new TRectTool("FillRect",State,TRUE);
 Tools[4]=new TEllipseTool("Ellipse",State,FALSE);
 Tools[5]=new TEllipseTool("FillEllipse",State,TRUE);
 Tools[6]=new TFillTool("Fill",State);
 Tools[7]=new TSelectTool("Select",State);
 State->DrawTool=Tools[0];
};

TToolBar::~TToolBar()
{
 State->DrawTool->Done();
 for (int i=0;i<ToolCount;i++)
  delete Tools[i];
};

void TToolBar::Paint(HDC PaintDC,PAINTSTRUCT&)
{
 int N;
 RECT R;
 for (N=0;N<ToolCount;N++)
 {
  DrawIcon(PaintDC,N*IconSize,0,Tools[N]->GetIcon());
  if (Tools[N]==State->DrawTool)
  {
   R.top=1;
   R.left=N*IconSize;
   R.bottom=R.top+30;
   R.right=R.left+30;
   InvertRect(PaintDC,&R);
  }
 }
};

void TToolBar::WMLButtonDown(TMessage& Message)
{
 int N=Message.LP.Lo/IconSize;
 if (N<ToolCount)
 {
  State->DrawTool->Done();
  State->DrawTool=Tools[N];
  InvalidateRect(HWindow,NULL,FALSE);
 }
};

void TLineBar::Paint(HDC PaintDC,PAINTSTRUCT&)
{
 int X=4;
 for (int N=0;N<LineCount;N++)
 {
  DrawLine(PaintDC,X,N);
  if (N==Choice)
  {
   Notch(PaintDC,X,0,TRUE,N);
   Notch(PaintDC,X,29,FALSE,N);
  }
  X+=GetLineWidth(N)+4;
 }
};

void TLineBar::SelectLine(TMessage& Message)
{
 int X=3;
 for (int N=0;N<LineCount;N++)
  if (Message.LP.Lo>=X && Message.LP.Lo<(X+=GetLineWidth(N)+4))
  {
   Choice=N;
   InvalidateRect(HWindow,NULL,TRUE);
   break;
  }
};

int TLineBar::GetBarWidth()
{
 int W=6;
 for (int N=0;N<LineCount;N++)
  W+=GetLineWidth(N)+4;
 return (W);
};

void TLineBar::Notch(HDC PaintDC,int X,int Y,BOOL Dir,int LineNo)
{
 int Pos=GetLineWidth(LineNo)/2+X;
 SelectObject(PaintDC,GetStockObject(BLACK_PEN));
 for (int L=3;L>=0;L--)
 {
  MoveTo(PaintDC,Pos-L,Y);
  LineTo(PaintDC,Pos+L+1,Y);
  if (Dir)
   Y++;
   else Y--;
 }
};

void TLineWidthBar::DrawLine(HDC PaintDC,int X,int LineNo)
{
 int W=GetLineWidth(LineNo);
 RECT R;
 SetRect(&R,X,5,X+W,25);
 FillRect(PaintDC,&R,(HBRUSH)GetStockObject(BLACK_BRUSH));
};

void TLineStyleBar::DrawLine(HDC PaintDC,int X,int LineNo)
{
 HPEN Pen=(HPEN)SelectObject(PaintDC,CreatePen(LineStyle[LineNo],
                                               1,RGB(0,0,0)));
 MoveTo(PaintDC,X,5);
 LineTo(PaintDC,X,24);
 DeleteObject(SelectObject(PaintDC,Pen));
};

void TPercentageBar::Paint(HDC PaintDC,PAINTSTRUCT&)
{
 int X;
 RECT R;
 GetClientRect(HWindow,&R);
 SelectObject(PaintDC,GetStockObject(BLACK_PEN));
 MoveTo(PaintDC,4,R.bottom-12);
 LineTo(PaintDC,R.right-5,R.bottom-12);
 for (X=4;X<R.right-5;X++)
  if (X%2==0)
  {
   MoveTo(PaintDC,X,R.bottom-12);
   LineTo(PaintDC,X,R.bottom-16);
   if ((X-4)%10==0)
    LineTo(PaintDC,X,R.bottom-((X-4)%20==0? 21 : 19));
  }
 Notch(PaintDC,*PValue*(R.right-10)/100+4,R.bottom-25);
};

void TPercentageBar::Notch(HDC PaintDC,int X,int Y)
{
 SelectObject(PaintDC,GetStockObject(BLACK_PEN));
 MoveTo(PaintDC,X,Y-3);
 LineTo(PaintDC,X-3,Y);
 LineTo(PaintDC,X,Y+3);
 LineTo(PaintDC,X+3,Y);
 LineTo(PaintDC,X,Y-3);
 SelectObject(PaintDC,GetStockObject(BLACK_BRUSH));
 ExtFloodFill(PaintDC,X,Y,GetPixel(PaintDC,X,Y),FLOODFILLSURFACE);
};

void TPercentageBar::WMLButtonDown(TMessage& Message)
{
 RECT R;
 GetClientRect(HWindow,&R);
 if (Message.LP.Lo<4)
  *PValue=0;
  else if (Message.LP.Lo>=R.right-5)
   *PValue=100;
   else *PValue=(Message.LP.Lo-4)*100/(R.right-10);
 InvalidateRect(HWindow,NULL,TRUE);
};

TCanvas::TCanvas(PTWindowsObject AParent,PTState AState)
                : TWindow(AParent,NULL)
{
 HDC DC=GetDC(0);
 HDC MemDC=CreateCompatibleDC(DC);
 Attr.Style=WS_BORDER | WS_CHILD | WS_VISIBLE;
 State=AState;
 Drawing=FALSE;
 State->BitMap=CreateCompatibleBitmap(DC,BitMapWidth,BitMapHeight);
 SelectObject(MemDC,State->BitMap);
 PatBlt(MemDC,0,0,BitMapWidth,BitMapHeight,WHITENESS);
 DeleteDC(MemDC);
 ReleaseDC(0,DC);
};

void TCanvas::Paint(HDC PaintDC,PAINTSTRUCT&)
{
 RECT R;
 HDC MemDC=CreateCompatibleDC(PaintDC);
 SelectObject(MemDC,State->BitMap);
 GetClientRect(HWindow,&R);
 BitBlt(PaintDC,0,0,R.right,R.bottom,MemDC,0,0,SRCCOPY);
 DeleteDC(MemDC);
};

void TCanvas::SaveDC()
{
 RECT R;
 HDC DC=GetDC(HWindow);
 HDC MemDC=CreateCompatibleDC(DC);
 SelectObject(MemDC,State->BitMap);
 GetClientRect(HWindow,&R);
 BitBlt(MemDC,0,0,R.right,R.bottom,DC,0,0,SRCCOPY);
 DeleteDC(MemDC);
 ReleaseDC(HWindow,DC);
};

void TCanvas::ButtonDown(TMessage& Message,COLORREF Color)
{
 if (!Drawing &&
     State->DrawTool->MouseDown(HWindow,
                                Message.LP.Lo,Message.LP.Hi,Color))
 {
  SaveDC();
  State->DrawTool->MouseMove(Message.LP.Lo,Message.LP.Hi);
 }
 Drawing=TRUE;
};

void TCanvas::WMMouseMove(TMessage& Message)
{
 if (Drawing)
  State->DrawTool->MouseMove(Message.LP.Lo,Message.LP.Hi);
};

void TCanvas::WMLButtonUp(TMessage&)
{
 if (Drawing)
 {
  State->DrawTool->MouseUp();
  Drawing=FALSE;
  SaveDC();
 }
};

void TClearAll::Run(PTState State,HWND CanvasWindow)
{
 HDC DC=GetDC(CanvasWindow);
 HDC MemDC=CreateCompatibleDC(DC);
 SelectObject(MemDC,State->BitMap);
 PatBlt(MemDC,State->Area.left,State->Area.top,
        State->Area.right-State->Area.left,
        State->Area.bottom-State->Area.top,WHITENESS);
 DeleteDC(MemDC);
 ReleaseDC(CanvasWindow,DC);
 InvalidateRect(CanvasWindow,&State->Area,TRUE);
};

void TClipboardRead::Run(PTState State,HWND CanvasWindow)
{
 if (OpenClipboard(CanvasWindow))
 {
  HANDLE Image=GetClipboardData(CF_BITMAP);
  if (Image)
  {
   HDC DC=GetDC(CanvasWindow);
   HDC MemDC=CreateCompatibleDC(DC);
   HDC MapDC=CreateCompatibleDC(MemDC);
   SelectObject(MemDC,State->BitMap);
   SelectObject(MapDC,Image);
   BitBlt(MemDC,State->Area.left,State->Area.top,
          State->Area.right-State->Area.left,
          State->Area.bottom-State->Area.top,
          MapDC,0,0,SRCCOPY);
   DeleteDC(MapDC);
   DeleteDC(MemDC);
   ReleaseDC(CanvasWindow,DC);
   InvalidateRect(CanvasWindow,&State->Area,TRUE);
  }
  CloseClipboard();
 }
};

TMenuBar::TMenuBar(PTWindowsObject AParent,PTState AState,PTCanvas ACanvas)
                  : TWindow(AParent,NULL)
{
 Attr.Style=WS_CHILD | WS_VISIBLE;
 State=AState;
 Canvas=ACanvas;
 Items[0]=new TClearAll("ClearAll");
 Items[1]=new TClipboardRead("ClipboardRead");
 Items[2]=new TBlurringEffect("Blurring");
 Items[3]=new TSharpeningEffect("Sharpening");
 Items[4]=new TEmbassingEffect("Embassing");
 Items[5]=new TWColoringEffect("WaterColoring");
 Items[6]=new TMakeNegative("MakeNegative");
 Items[7]=new TControlBrightness("ControlBrightness");
 Items[8]=new TControlContrast("ControlContrast");
 Items[9]=new TControlSaturation("ControlSaturation");
 Items[10]=new TControlRed("ControlRed");
 Items[11]=new TControlGreen("ControlGreen");
 Items[12]=new TControlBlue("ControlBlue");
};

TMenuBar::~TMenuBar()
{
 for (int i=0;i<MenuCount;i++)
  delete Items[i];
};

void TMenuBar::Paint(HDC PaintDC,PAINTSTRUCT&)
{
 int N;
 for (N=0;N<MenuCount;N++)
  DrawIcon(PaintDC,N*IconSize,0,Items[N]->GetIcon());
};

void TMenuBar::WMLButtonDown(TMessage& Message)
{
 HCURSOR Cursor;
 int N=Message.LP.Lo/IconSize;
 if (N<MenuCount)
 {
  Cursor=SetCursor(LoadCursor(NULL,IDC_WAIT));
  Items[N]->Run(State,Canvas->HWindow);
  SetCursor(Cursor);
 }
};

TGraphEffectsWin::TGraphEffectsWin(PTWindowsObject AParent,LPSTR ATitle)
                                  : TWindow(AParent,ATitle)
{
 State.DrawTool=NULL;
 State.BitMap=0;
 State.PenWidth=LineWidth[0];
 State.PenStyle=LineStyle[0];
 State.Background=RGB(255,255,255);
 State.Foreground=RGB(0,0,0);
 State.EffectLevel=50;
 SetRect(&State.Area,0,0,BitMapWidth,BitMapHeight);
 Canvas=new TCanvas(this,&State);
 Palette=new TPalette(this,&State);
 ToolBar=new TToolBar(this,&State);
 MenuBar=new TMenuBar(this,&State,Canvas);
 LineWidthBar=new TLineWidthBar(this,&State);
 LineStyleBar=new TLineStyleBar(this,&State);
 PercentageBar=new TPercentageBar(this,&State.EffectLevel);
};

TGraphEffectsWin::~TGraphEffectsWin()
{
 delete PercentageBar;
 delete LineStyleBar;
 delete LineWidthBar;
 delete MenuBar;
 delete ToolBar;
 delete Palette;
 delete Canvas;
};

void TGraphEffectsWin::GetWindowClass(WNDCLASS& WndClass)
{
 TWindow::GetWindowClass(WndClass);
 WndClass.hbrBackground=(HBRUSH)COLOR_APPWORKSPACE+1;
 WndClass.hIcon=LoadIcon(GetApplication()->hInstance,"ProgramIcon");
};

void TGraphEffectsWin::WMSize(TMessage&)
{
 int S;
 RECT R;
 GetClientRect(HWindow,&R);
 S=((R.bottom-8)/17)*3+1;
 MoveWindow(Palette->HWindow,4,4,S,R.bottom-8,TRUE);
 MoveWindow(ToolBar->HWindow,S+8,4,ToolCount*IconSize,IconSize,TRUE);
 MoveWindow(LineWidthBar->HWindow,S+MenuCount*IconSize+10,4,
            LineWidthBar->GetBarWidth(),IconSize,TRUE);
 MoveWindow(LineStyleBar->HWindow,
            S+MenuCount*IconSize+LineWidthBar->GetBarWidth()+14,4,
            LineStyleBar->GetBarWidth(),IconSize,TRUE);
 MoveWindow(MenuBar->HWindow,S+8,IconSize+6,
            MenuCount*IconSize,IconSize,TRUE);
 MoveWindow(PercentageBar->HWindow,S+MenuCount*IconSize+10,IconSize+6,
            100*2+12,IconSize,TRUE);
 MoveWindow(Canvas->HWindow,S+8,2*IconSize+10,
            R.right-S-12,R.bottom-2*IconSize-14,TRUE);
};

int PASCAL WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
                   LPSTR lpCmd,int nCmdShow)
{
 TGraphEffectsApp App("Graph Special Effects Tool",
                      hInstance,hPrevInstance,lpCmd,nCmdShow);
 App.Run();
 return (App.Status);
}