// FxDlg.cpp : implementation file
//

#include "stdafx.h"
#include "FxDemo.h"
#include "FxDlg.h"
#include <windowsx.h>

#define MAX_IMAGES 5

#define DIR TEXT("..\\images")

L_TCHAR L_FAR *aszFileName[MAX_IMAGES]={0};

/////////////////////////////////////////////////////////////////////////////
// CFxDemoDlg dialog
L_INT FillFileNameArray(L_TCHAR L_FAR* pszDir)
{
   L_INT x;
   L_TCHAR szFile[L_MAXPATH]=TEXT("\0");
   for(x=0;x<MAX_IMAGES;x++)
   {
      wsprintf(szFile, TEXT("sample%d.cmp"), x+1);
      if(!aszFileName[x])
         aszFileName[x] = (L_TCHAR L_FAR*)GlobalAllocPtr(GMEM_MOVEABLE|GMEM_ZEROINIT, L_MAXPATH*sizeof(L_TCHAR));
      if(!aszFileName[x])
         return ERROR_NO_MEMORY;
      lstrcpy(aszFileName[x], pszDir);
      lstrcat(aszFileName[x], TEXT("\\"));
      lstrcat(aszFileName[x], szFile);
   }
   return SUCCESS;
}

L_VOID FreeFileNameArray(L_VOID)
{
   L_INT x;
   for(x=0;x<MAX_IMAGES;x++)
   {
      if(aszFileName[x])
         GlobalFreePtr(aszFileName[x]);
   }
}

CFxDemoDlg::CFxDemoDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CFxDemoDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CFxDemoDlg)
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
   m_bDlgUp = FALSE;
   L_DlgInit(DLG_INIT_COLOR);
}

CFxDemoDlg::~CFxDemoDlg()
{
   FreeFileNameArray();
   L_DlgFree();
}

void CFxDemoDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CFxDemoDlg)
	DDX_Control(pDX, IDC_IMAGE, m_Image);
	DDX_Control(pDX, IDC_SHOW_TRANSITION, m_ShowTransition);
	DDX_Control(pDX, IDC_SHOW_TEXT, m_ShowText);
	DDX_Control(pDX, IDC_SHOW_SHAPE, m_ShowShape);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CFxDemoDlg, CDialog)
	//{{AFX_MSG_MAP(CFxDemoDlg)
	ON_BN_CLICKED(IDC_EFFECT, OnEffect)
	ON_BN_CLICKED(IDC_SHAPE, OnShape)
	ON_BN_CLICKED(IDC_SHOW, OnShow)
	ON_BN_CLICKED(IDC_TEXT, OnText)
	ON_BN_CLICKED(IDC_TRANSITION, OnTransition)
	ON_WM_DRAWITEM()
	ON_WM_CLOSE()
    ON_WM_PALETTECHANGED()
    ON_WM_QUERYNEWPALETTE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CFxDemoDlg message handlers

BOOL CFxDemoDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

#ifdef _WIN32
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
#endif
	
   L_InitBitmap(&m_ShapeBitmap, sizeof(BITMAPHANDLE),100, 100, 1);
   L_InitBitmap(&m_TextBitmap, sizeof(BITMAPHANDLE),100, 100, 1);
   m_nEffectStyle             = EFX_EFFECT_ELLIPSE_C_OUT;
   m_nEffectGrain             = 10;
   m_nEffectDelay             = 0;
   m_nEffectMaxPass           = 1;
   m_nEffectTransparent       = 0;
   m_crEffectTransparentColor = RGB(0, 0, 0);
   m_nEffectWandWidth         = 0;
   m_crEffectWandColor        = RGB(255, 0, 0);

   m_nTransitionStyle                   = EFX_TRANS_GRADIENT_CONE_FROM_B;  
   m_crTransitionBackColor              = RGB(255, 0, 0);       
   m_crTransitionForeColor              = RGB(0, 0, 255);       
   m_nTransitionSteps                   = 100;       
   m_nTransitionEffectStyle             = EFX_EFFECT_ELLIPSE_C_IN;      
   m_nTransitionEffectGrain             = 10;       
   m_nTransitionEffectDelay             = 0;       
   m_nTransitionEffectMaxPass           = 1;     
   m_nTransitionEffectTransparent       = 0; 
   m_crTransitionEffectTransparentColor = RGB(128, 128, 128);
   m_nTransitionEffectWandWidth         = 0;   
   m_crTransitionEffectWandColor        = RGB(0, 128, 0);       

	m_nShapeStyle             = EFX_SHAPE_STAR5;
	m_nShapeBackStyle         = EFX_BACKSTYLE_TRANSPARENT;
	m_nShapeFillStyle         = EFX_FILLSTYLE_FDIAGONAL;
	m_crShapeBorderColor      = RGB(192, 192, 192);
	m_nShapeBorderStyle       = EFX_BORDERSTYLE_SOLID;
	m_nShapeBorderWidth       = 3;
	m_nShapeInnerStyle        = EFX_INNERSTYLE_INSET;
	m_nShapeInnerWidth        = 3;
	m_crShapeInnerHiliteColor = RGB(255, 255, 255);
	m_crShapeInnerShadowColor = RGB(128, 128, 128);
	m_nShapeOuterStyle        = EFX_OUTERSTYLE_RAISED;
	m_nShapeOuterWidth        = 3;
	m_crShapeOuterHiliteColor = RGB(255, 255, 255);
	m_crShapeOuterShadowColor = RGB(128, 128, 128);
	m_nShapeShadowXDepth      = 5;
	m_nShapeShadowYDepth      = 5;
	m_crShapeShadowColor      = RGB(0, 0, 0);
	m_crShapeForeColor        = RGB(255, 0, 0);
	m_crShapeBackColor        = RGB(0, 0, 255);
   
   m_TextFont.lfHeight         = 72;
   m_TextFont.lfWidth          = 0;
   m_TextFont.lfEscapement     = 0;
   m_TextFont.lfOrientation    = 0;
   m_TextFont.lfWeight         = FW_BOLD;
   m_TextFont.lfItalic         = FALSE;
   m_TextFont.lfUnderline      = FALSE;
   m_TextFont.lfStrikeOut      = FALSE;
   m_TextFont.lfCharSet        = DEFAULT_CHARSET;
   m_TextFont.lfOutPrecision   = OUT_DEFAULT_PRECIS;
   m_TextFont.lfClipPrecision  = CLIP_DEFAULT_PRECIS;
   m_TextFont.lfQuality        = DEFAULT_QUALITY;
   m_TextFont.lfPitchAndFamily = DEFAULT_PITCH;
   lstrcpy(m_TextFont.lfFaceName, TEXT("Times New Roman"));

   lstrcpy(m_szTextSample, TEXT("LEADTOOLS"));
   m_nTextAngle              = 0;        
   m_nTextStyle              = EFX_TEXT_OUTLINEBLOCK;        
   m_nTextAlign              = EFX_TEXT_HCENTER | EFX_TEXT_VCENTER;        
   m_nTextWordWrap           = 1;     
   m_crTextColor             = RGB(255, 0, 0);
   m_crTextHiliteColor       = RGB(255, 255, 255);
   m_crTextShadowColor       = RGB(0, 0, 0);
   m_nTextShadowXDepth       = 5;
   m_nTextShadowYDepth       = 5;
   m_nTextUseForegroundImage = 0;

   UNLOCKSUPPORT();

   m_nFileIndex = 0;
   L_InitBitmap(&m_Bitmap,sizeof(BITMAPHANDLE), 100, 100, 16);

   m_bFilesNotFound = FALSE;
   if(FillFileNameArray(DIR)!=SUCCESS)
   {
      AfxMessageBox(TEXT("Error, No More Memory!"));
      EndDialog(IDCANCEL);
   }

	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CFxDemoDlg::OnClose() 
{
   if (m_Bitmap.Flags.Allocated)
   {
      L_FreeBitmap(&m_Bitmap);
   }
   
   if (m_TextBitmap.Flags.Allocated)
   {
      L_FreeBitmap(&m_TextBitmap);
   }
   
   if (m_ShapeBitmap.Flags.Allocated)
   {
      L_FreeBitmap(&m_ShapeBitmap);
   }
   
	CDialog::OnClose();
}

void CFxDemoDlg::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct) 
{
   if (lpDrawItemStruct->CtlID == IDC_IMAGE)
   {
      OnShow();
      if(m_bFilesNotFound)
         EndDialog(IDCANCEL);
   }
}

void CFxDemoDlg::OnPaletteChanged( CWnd* pWnd)
{
   HPALETTE hPal, hOldPal;
   
   CDC *pDC = m_Image.GetWindowDC();
   
   if (pWnd->m_hWnd != this->m_hWnd)
   {
      OutputDebugString(TEXT("OnPaletteChanged\n"));
      hPal = L_CreatePaintPalette(pDC->m_hDC, &m_Bitmap);
      if(hPal)
      {
         hOldPal = ::SelectPalette(pDC->m_hDC, hPal, TRUE );
         ::RealizePalette(pDC->m_hDC);
      }
      pWnd->ReleaseDC(pDC);
      
      if (hPal)
      {
         //decrement counter so same image is repainted
         m_nFileIndex = (m_nFileIndex + MAX_IMAGES-1) % MAX_IMAGES;
         InvalidateRect(NULL,TRUE);
         ::DeleteObject(hOldPal);
      }
   }
}

BOOL CFxDemoDlg::OnQueryNewPalette( )
{
   HPALETTE hPal, hOldPal;
   BOOL bRet = FALSE;  //return TRUE if realizes palette

   CDC *pDC = m_Image.GetWindowDC();

   OutputDebugString(TEXT("OnQueryNewPalette\n"));
   hPal = L_CreatePaintPalette(pDC->m_hDC, &m_Bitmap);
   if(hPal)
   {
      hOldPal = ::SelectPalette(pDC->m_hDC, hPal, FALSE );
      ::RealizePalette(pDC->m_hDC);
      bRet = TRUE;
   }
   //pWnd->ReleaseDC(pDC);

  
   if (hPal)
   {
         //decrement counter so same image is repainted
         //m_nFileIndex = (m_nFileIndex + MAX_IMAGES-1) % MAX_IMAGES;

     // InvalidateRect(NULL,TRUE);
      ::DeleteObject(hOldPal);
   }
   m_Image.ReleaseDC(pDC);
   return bRet;
}

void CFxDemoDlg::OnEffect() 
{
   L_INT           nResult;
   CRect           rcRect;
   EFFECTDLGPARAMS Parm;
   TCHAR        szCurrentDir[MAX_PATH];
   GetCurrentDirectory(MAX_PATH,szCurrentDir);

   memset(&Parm,0,sizeof(Parm));

   Parm.uStructSize         =  sizeof(Parm);  
   Parm.uEffect       =  m_nEffectStyle;      
   Parm.uGrain        =  m_nEffectGrain;       
   Parm.uDelay        =  m_nEffectDelay;       
   Parm.uMaxPass      =  m_nEffectMaxPass;     
   Parm.bTransparent  =  m_nEffectTransparent; 
   Parm.crTransparent =  m_crEffectTransparentColor;
   Parm.uWandWidth    =  m_nEffectWandWidth;   
   Parm.crWand        =  m_crEffectWandColor;     
   Parm.pBitmap       =  &m_Bitmap;
   Parm.uDlgFlags     =  DLG_EFFECT_SHOW_PREVIEW |
                         DLG_EFFECT_DELAY |
                         DLG_EFFECT_GRAIN |
                         DLG_EFFECT_PASSES |
                         DLG_EFFECT_TRANSPARENT |
                         DLG_EFFECT_WAND |
                         DLG_EFFECT_CLASS_NONE |
                         DLG_EFFECT_CLASS_WIPE |
                         DLG_EFFECT_CLASS_WIPERECT |
                         DLG_EFFECT_CLASS_WIPECIRCLE |
                         DLG_EFFECT_CLASS_PUSH |
                         DLG_EFFECT_CLASS_SLIDE |
                         DLG_EFFECT_CLASS_ROLL |
                         DLG_EFFECT_CLASS_ROTATE |
                         DLG_EFFECT_CLASS_ZOOM |
                         DLG_EFFECT_CLASS_DRIP |
                         DLG_EFFECT_CLASS_BLIND |
                         DLG_EFFECT_CLASS_RANDOM |
                         DLG_EFFECT_CLASS_CHECK |
                         DLG_EFFECT_CLASS_BLOCKS |
                         DLG_EFFECT_CLASS_CIRCLE |
                         DLG_EFFECT_CLASS_ELLIPSE;


   m_bDlgUp = TRUE;
   nResult = L_DlgGetEffect(this->m_hWnd,&Parm);
   m_bDlgUp = FALSE;
   SetCurrentDirectory(szCurrentDir);
   if (nResult == SUCCESS_DLG_OK)
   {
      m_nEffectStyle             = Parm.uEffect;
      m_nEffectGrain             = Parm.uGrain;       
      m_nEffectDelay             = Parm.uDelay;       
      m_nEffectMaxPass           = Parm.uMaxPass;     
      m_nEffectTransparent       = Parm.bTransparent; 
      m_crEffectTransparentColor = Parm.crTransparent;
      m_nEffectWandWidth         = Parm.uWandWidth;   
      m_crEffectWandColor        = Parm.crWand;       

      InvalidateRect(NULL, FALSE);
   }
}

void CFxDemoDlg::OnTransition() 
{
   L_INT        nResult;
   CRect        rcRect;
   TRANSITIONDLGPARAMS  Parm;

   TCHAR        szCurrentDir[MAX_PATH];
   GetCurrentDirectory(MAX_PATH,szCurrentDir);

   memset(&Parm,0,sizeof(Parm));

   Parm.uStructSize   = sizeof(Parm);  
   Parm.uTransition   = m_nTransitionStyle;  
   Parm.crBack        = m_crTransitionBackColor;     
   Parm.crFore        = m_crTransitionForeColor;     
   Parm.uSteps        = m_nTransitionSteps;       
   Parm.uEffect       = m_nTransitionEffectStyle;      
   Parm.uGrain        = m_nTransitionEffectGrain;       
   Parm.uDelay        = m_nTransitionEffectDelay;       
   Parm.uMaxPass      = m_nTransitionEffectMaxPass;      
   Parm.bTransparent  = m_nTransitionEffectTransparent; 
   Parm.crTransparent = m_crTransitionEffectTransparentColor;
   Parm.uWandWidth    = m_nTransitionEffectWandWidth;   
   Parm.crWand        = m_crTransitionEffectWandColor;     
   Parm.pBitmap       = &m_Bitmap;
   Parm.uDlgFlags     = DLG_TRANSITION_SHOW_PREVIEW |
                        DLG_TRANSITION_FORECOLOR |
                        DLG_TRANSITION_BACKCOLOR |
                        DLG_TRANSITION_DELAY |
                        DLG_TRANSITION_GRAIN |
                        DLG_TRANSITION_EFFECT |
                        DLG_TRANSITION_PASSES |
                        DLG_TRANSITION_WAND |
                        DLG_TRANSITION_TRANSPARENT |
                        DLG_TRANSITION_GRADIENT;


   m_bDlgUp = TRUE;
   nResult = L_DlgGetTransition(this->m_hWnd,&Parm);

   m_bDlgUp = FALSE;
   SetCurrentDirectory(szCurrentDir);

   if (nResult == SUCCESS_DLG_OK)
   {
      m_nTransitionStyle                   = Parm.uTransition;  
      m_crTransitionBackColor              = Parm.crBack;       
      m_crTransitionForeColor              = Parm.crFore;       
      m_nTransitionSteps                   = Parm.uSteps;       
      m_nTransitionEffectStyle             = Parm.uEffect;      
      m_nTransitionEffectGrain             = Parm.uGrain;       
      m_nTransitionEffectDelay             = Parm.uDelay;       
      m_nTransitionEffectMaxPass           = Parm.uMaxPass;     
      m_nTransitionEffectTransparent       = Parm.bTransparent; 
      m_crTransitionEffectTransparentColor = Parm.crTransparent;
      m_nTransitionEffectWandWidth         = Parm.uWandWidth;   
      m_crTransitionEffectWandColor        = Parm.crWand;       

      m_ShowTransition.SetCheck(TRUE);

      InvalidateRect(NULL, FALSE);
   }
}

void CFxDemoDlg::OnShape() 
{
   L_INT            nResult;
   CRect           rcRect;
   SHAPEDLGPARAMS  Parm;
   TCHAR        szCurrentDir[MAX_PATH];

   memset(&Parm,0,sizeof(Parm));

   Parm.uStructSize   = sizeof(Parm);
   Parm.uShape        = m_nShapeStyle; 
   Parm.crBack        = m_crShapeBackColor;	                  
   Parm.uBackStyle    = m_nShapeBackStyle;                  
   Parm.crFill        = m_crShapeForeColor;                    
   Parm.uFillStyle    = m_nShapeFillStyle;                  
   Parm.crBorder      = m_crShapeBorderColor;                  
   Parm.uBorderStyle  = m_nShapeBorderStyle;                
   Parm.uBorderWidth  = m_nShapeBorderWidth;                
   Parm.crInnerHilite = m_crShapeInnerHiliteColor;             
   Parm.crInnerShadow = m_crShapeInnerShadowColor;             
   Parm.uInnerStyle   = m_nShapeInnerStyle;                 
   Parm.uInnerWidth   = m_nShapeInnerWidth;                 
   Parm.crOuterHilite = m_crShapeOuterHiliteColor;             
   Parm.crOuterShadow = m_crShapeOuterShadowColor;             
   Parm.uOuterStyle   = m_nShapeOuterStyle;                 
   Parm.uOuterWidth   = m_nShapeOuterWidth;                 
   Parm.nShadowX      = m_nShapeShadowXDepth;                     
   Parm.nShadowY      = m_nShapeShadowYDepth;                     
   Parm.crShadow      = m_crShapeShadowColor;                  
   Parm.pBitmap       = &m_Bitmap;
   
   Parm.pBackgroundBitmap  = &m_ShapeBitmap;

   Parm.uDlgFlags     =DLG_SHAPE_SHOW_PREVIEW |
                       DLG_SHAPE_BACKSTYLE |
                       DLG_SHAPE_FILLSTYLE |
                       DLG_SHAPE_FORE_BACK_COLOR |
                       DLG_SHAPE_BORDERSTYLE |
                       DLG_SHAPE_BORDERWIDTH |
                       DLG_SHAPE_BORDERCOLOR |
                       DLG_SHAPE_INNERSTYLE |
                       DLG_SHAPE_INNERWIDTH |
                       DLG_SHAPE_INNER_HILITE_SHADOW |
                       DLG_SHAPE_OUTERSTYLE |
                       DLG_SHAPE_OUTERWIDTH |
                       DLG_SHAPE_OUTER_HILITE_SHADOW |
                       DLG_SHAPE_SHADOWCOLOR |
                       DLG_SHAPE_SHADOW_X_Y |
                       DLG_SHAPE_BROWSEIMAGE |
                       DLG_SHAPE_CLASS_SQUARE |
                       DLG_SHAPE_CLASS_RECTANGLE |
                       DLG_SHAPE_CLASS_PARALLELOGRAM |
                       DLG_SHAPE_CLASS_TRAPEZOID |
                       DLG_SHAPE_CLASS_TRIANGLE |
                       DLG_SHAPE_CLASS_OTHER |
                       DLG_SHAPE_CLASS_CIRCLE |
                       DLG_SHAPE_CLASS_ELLIPSE |
                       DLG_SHAPE_CLASS_STAR |
                       DLG_SHAPE_CLASS_CROSS |
                       DLG_SHAPE_CLASS_ARROW;
                       


   GetCurrentDirectory(MAX_PATH,szCurrentDir);

   m_bDlgUp = TRUE;
   nResult = L_DlgGetShape(this->m_hWnd, &Parm);

   m_bDlgUp = FALSE;
   SetCurrentDirectory(szCurrentDir);

   if (nResult == SUCCESS_DLG_OK)
   {
      m_nShapeStyle                = Parm.uShape;       
      m_crShapeBackColor	        = Parm.crBack;                 
      m_nShapeBackStyle            = Parm.uBackStyle;          
      m_crShapeForeColor           = Parm.crFill;                 
      m_nShapeFillStyle            = Parm.uFillStyle;          
      m_crShapeBorderColor         = Parm.crBorder;               
      m_nShapeBorderStyle          = Parm.uBorderStyle;        
      m_nShapeBorderWidth          = Parm.uBorderWidth;        
      m_crShapeInnerHiliteColor    = Parm.crInnerHilite;          
      m_crShapeInnerShadowColor    = Parm.crInnerShadow;          
      m_nShapeInnerStyle           = Parm.uInnerStyle;         
      m_nShapeInnerWidth           = Parm.uInnerWidth;         
      m_crShapeOuterHiliteColor    = Parm.crOuterHilite;          
      m_crShapeOuterShadowColor    = Parm.crOuterShadow;          
      m_nShapeOuterStyle           = Parm.uOuterStyle;         
      m_nShapeOuterWidth           = Parm.uOuterWidth;         
      m_nShapeShadowXDepth         = Parm.nShadowX;                  
      m_nShapeShadowYDepth         = Parm.nShadowY;                  
      m_crShapeShadowColor         = Parm.crShadow;

      m_ShowShape.SetCheck(TRUE);

      InvalidateRect(NULL, FALSE);
   }
}

void CFxDemoDlg::OnText() 
{
   L_INT       nResult;
   HFONT       hFont;
   CRect       rcRect;
   TEXTDLGPARAMS Parm;
   TCHAR        szCurrentDir[MAX_PATH];
   GetCurrentDirectory(MAX_PATH,szCurrentDir);
   hFont = CreateFontIndirect(&m_TextFont);

   memset(&Parm,0,sizeof(Parm));

   Parm.uStructSize   = sizeof(TEXTDLGPARAMS); 
   Parm.pszSampleText = (LPTSTR)m_szTextSample;
   Parm.nMaxCount     = sizeof(m_szTextSample);   
   Parm.nAngle        = m_nTextAngle;      
   Parm.uStyle        = m_nTextStyle;      
   Parm.uAlign        = m_nTextAlign;      
   Parm.bWordWrap     = m_nTextWordWrap;   
   Parm.hFont         = hFont;       
   Parm.crText        = m_crTextColor;      
   Parm.crHilite      = m_crTextHiliteColor;    
   Parm.crShadow      = m_crTextShadowColor;    
   Parm.nXDepth       = m_nTextShadowXDepth;     
   Parm.nYDepth       = m_nTextShadowYDepth;     
   Parm.bUseForeImage = m_nTextUseForegroundImage;
   Parm.pBitmap       = &m_Bitmap;
   Parm.pForegroundBitmap     = &m_TextBitmap;
   Parm.uDlgFlags     =  DLG_TEXT_SHOW_PREVIEW |
                         DLG_TEXT_SAMPLETEXT |
                         DLG_TEXT_STYLE |
                         DLG_TEXT_COLOR |
                         DLG_TEXT_BORDERCOLOR |
                         DLG_TEXT_ALIGN |
                         DLG_TEXT_ANGLE |
                         DLG_TEXT_WORDWRAP |
                         DLG_TEXT_FONT |
                         DLG_TEXT_FOREIMAGE |
                         DLG_TEXT_BROWSEIMAGE |
                         DLG_TEXT_SHADOWCOLOR |
                         DLG_TEXT_SHADOW_X_Y;
                         
   
   m_bDlgUp = TRUE;

   nResult = L_DlgGetText(this->m_hWnd,&Parm);

  m_bDlgUp = FALSE;

   SetCurrentDirectory(szCurrentDir);
   DeleteObject(hFont);
   
   if (nResult == SUCCESS_DLG_OK)
   {
//      m_strTextSample           = Parm.pszSampleText;
      m_nTextAngle              = Parm.nAngle;        
      m_nTextStyle              = Parm.uStyle;        
      m_nTextAlign              = Parm.uAlign;        
      m_nTextWordWrap           = Parm.bWordWrap;     
      m_crTextColor             = Parm.crText;
      m_crTextHiliteColor       = Parm.crHilite;
      m_crTextShadowColor       = Parm.crShadow;
      m_nTextShadowXDepth       = Parm.nXDepth;
      m_nTextShadowYDepth       = Parm.nYDepth;
      m_nTextUseForegroundImage = Parm.bUseForeImage;

      GetObject(Parm.hFont, sizeof(LOGFONT), &m_TextFont);

      m_ShowText.SetCheck(TRUE);

      InvalidateRect(NULL, FALSE);
   }
}

void CFxDemoDlg::OnShow() 
{
   L_INT     nResult, i;
   FILEINFO  Info;
   HFONT     hFont;
   CRect     rcRect;
   CRect     rcRect2;
   HDC       hdcMemShape=0;
   HBITMAP   hbmMemShape;
   HDC       hdcMemText=0;
   HBITMAP   hbmMemText;
   CDC      *pDC;
   HPALETTE  hPal=NULL;
   HPALETTE  hOldPal=NULL;
   
   pDC = m_Image.GetWindowDC();
   m_Image.GetClientRect(rcRect);

   if(!m_bDlgUp && !m_bFilesNotFound)
   {
      if (m_Bitmap.Flags.Allocated)
      {
         L_FreeBitmap(&m_Bitmap);
      }

      nResult = L_FileInfo(aszFileName[m_nFileIndex], &Info,sizeof(Info), 0, NULL);
      L_InitBitmap(&m_Bitmap, sizeof(m_Bitmap),Info.Width, Info.Height, Info.BitsPerPixel);
      if (nResult == SUCCESS)
         nResult = L_LoadBitmap(aszFileName[m_nFileIndex], &m_Bitmap, sizeof(m_Bitmap),Info.BitsPerPixel, Info.Order, NULL, NULL);
      else if(nResult==ERROR_FILENOTFOUND)
      {
         L_TCHAR szDir[L_MAXPATH]=TEXT("\0");
         GETDIRECTORYDLGPARAMS DlgParms;
         DlgParms.uStructSize=sizeof(GETDIRECTORYDLGPARAMS);
         DlgParms.pszDirectory=szDir;
         DlgParms.nBuffSize=L_MAXPATH;
         DlgParms.pszFilter=NULL;
         DlgParms.nFilterIndex=0;
         DlgParms.pszTitle=TEXT("Please Select the LEADTOOLS Images Folder"); 
         DlgParms.pfnHelpCallback=NULL; 
         DlgParms.pHelpCallBackUserData=NULL;

         m_bFilesNotFound = TRUE;
         m_bDlgUp=TRUE;
         nResult = L_DlgGetDirectory(this->m_hWnd, &DlgParms);
         m_bDlgUp=FALSE;
         if(nResult != SUCCESS_DLG_OK)
            return;

         if(FillFileNameArray(DlgParms.pszDirectory)!=SUCCESS)
         {
            AfxMessageBox(TEXT("Error, No More Memory!"));
            return;
         }

         nResult = L_FileInfo(aszFileName[m_nFileIndex], &Info,sizeof(Info), 0, NULL);
         if(nResult != SUCCESS)
         {
            AfxMessageBox(TEXT("Can't find the image files!"));
            return;
         }
         nResult = L_LoadBitmap(aszFileName[m_nFileIndex], &m_Bitmap, sizeof(m_Bitmap),Info.BitsPerPixel, Info.Order, NULL, NULL);
         if(nResult != SUCCESS)
         {
            AfxMessageBox(TEXT("Can't find the image files!"));
            return;
         }
      }

      if(nResult != SUCCESS)
      {
         AfxMessageBox(TEXT("Can't find the image files!"));
         return;
      }
      m_bFilesNotFound = FALSE;
   }

   hPal = L_CreatePaintPalette(pDC->m_hDC, &m_Bitmap);
   if(hPal)
   {
      hOldPal = ::SelectPalette(pDC->m_hDC, hPal, TRUE );
      ::RealizePalette(pDC->m_hDC);
   }

   /*
   m_nFileIndex++;
   if (m_nFileIndex >= sizeof(szFileName) / sizeof(szFileName[0]))
   {
      m_nFileIndex = 0;
   }
   */

   m_nFileIndex = (m_nFileIndex + 1) % MAX_IMAGES;

   L_EfxDrawFrame(pDC->m_hDC, 
                  &rcRect, 
                  EFX_FRAME_ADJUST_RECT | EFX_FRAME_OUTER_RAISED, 
                  2, RGB(192, 192, 192),
                  2, RGB(128, 128, 128), RGB(255, 255, 255),
                  2, RGB(128, 128, 128), RGB(255, 255, 255));

   if (m_ShowTransition.GetCheck())
   {
      for (i = 0; i < m_nTransitionEffectMaxPass; i++)
      {
         L_EfxPaintTransition(pDC->m_hDC,
                              m_nTransitionStyle,
                              m_crTransitionBackColor,
                              m_crTransitionForeColor,
                              m_nTransitionSteps,
                              &rcRect,
                              m_nTransitionEffectStyle,
                              m_nTransitionEffectGrain,
                              m_nTransitionEffectDelay,
                              0,
                              0,
                              i+1,
                              m_nTransitionEffectMaxPass,
                              m_nTransitionEffectTransparent,
                              m_crTransitionEffectTransparentColor,
                              m_nTransitionEffectWandWidth,
                              m_crTransitionEffectWandColor,
                              SRCCOPY);
      }
   }

   for (i = 0; i < m_nEffectMaxPass; i++)
   {
      L_EfxPaintBitmap(pDC->m_hDC, 
                       &m_Bitmap, 
                       NULL, 
                       NULL, 
                       &rcRect, 
                       &rcRect, 
                       m_nEffectStyle, 
                       m_nEffectGrain,
                       m_nEffectDelay,
                       0,
                       0,
                       i+1, 
                       m_nEffectMaxPass,
                       m_nEffectTransparent,
                       m_crEffectTransparentColor,
                       m_nEffectWandWidth,
                       m_crEffectWandColor,
                       SRCCOPY);
   }

   rcRect2 = rcRect;
   rcRect2.OffsetRect(-rcRect2.left, -rcRect2.top);

   if (m_ShapeBitmap.Flags.Allocated)
   {
      hdcMemShape = CreateCompatibleDC(pDC->m_hDC);      
      hbmMemShape = CreateCompatibleBitmap(pDC->m_hDC, rcRect2.Width(), rcRect2.Height());
      SelectObject(hdcMemShape, hbmMemShape);

      HPALETTE hPalette = L_CreatePaintPalette(hdcMemShape, &m_ShapeBitmap);
      HPALETTE hPaletteOld = NULL;
      if (hPalette)
      {
         hPaletteOld = SelectPalette(hdcMemShape, hPalette, TRUE);
         RealizePalette(hdcMemShape);
      }


      L_EfxPaintBitmap(hdcMemShape, 
                       &m_ShapeBitmap, 
                       NULL, 
                       NULL, 
                       &rcRect2, 
                       &rcRect2, 
                       EFX_EFFECT_NONE, 
                       1,
                       0,
                       0,
                       0,
                       1, 1,
                       0,
                       0,
                       0,
                       0,
                       SRCCOPY);

      if (hPaletteOld)
      {
         SelectPalette(hdcMemShape, hPaletteOld, TRUE);
         DeleteObject(hPalette);
      }
   }

   if ((m_TextBitmap.Flags.Allocated) && (m_nTextUseForegroundImage))
   {
      hdcMemText = CreateCompatibleDC(pDC->m_hDC);
      hbmMemText = CreateCompatibleBitmap(pDC->m_hDC, rcRect2.Width(), rcRect2.Height());
      SelectObject(hdcMemText, hbmMemText);
      
      L_EfxPaintBitmap(hdcMemText, 
                       &m_TextBitmap, 
                       NULL, 
                       NULL, 
                       &rcRect2, 
                       &rcRect2, 
                       EFX_EFFECT_NONE, 
                       1,
                       0,
                       0,
                       0,
                       1, 1,
                       0,
                       0,
                       0,
                       0,
                       SRCCOPY);
   }

   if (m_ShowShape.GetCheck())
   {

      L_EfxDraw3dShape(pDC->m_hDC,
                       m_nShapeStyle,
                       &rcRect,
                       m_crShapeBackColor,
                       hdcMemShape,
                       &rcRect,
                       m_nShapeBackStyle,
                       m_crShapeForeColor,
                       m_nShapeFillStyle,
                       m_crShapeBorderColor,
                       m_nShapeBorderStyle,
                       m_nShapeBorderWidth,
                       m_crShapeInnerHiliteColor,
                       m_crShapeInnerShadowColor,
                       m_nShapeInnerStyle,
                       m_nShapeInnerWidth,
                       m_crShapeOuterHiliteColor,
                       m_crShapeOuterShadowColor,
                       m_nShapeOuterStyle,
                       m_nShapeOuterWidth,
                       m_nShapeShadowXDepth,
                       m_nShapeShadowYDepth,
                       m_crShapeShadowColor,
                       NULL);

   }

   if (m_ShowText.GetCheck())
   {
      hFont = CreateFontIndirect(&m_TextFont);

      L_EfxDrawRotated3dText(pDC->m_hDC,
                             m_szTextSample,
                             &rcRect,
                             m_nTextAngle,
                             m_nTextStyle | m_nTextAlign | (m_nTextWordWrap << 12),
                             m_nTextShadowXDepth, 
                             m_nTextShadowYDepth,
                             m_crTextColor,
                             m_crTextShadowColor,
                             m_crTextHiliteColor,
                             hFont,
                             hdcMemText);

      DeleteObject(hFont);
   }

   if(hPal)
   {
      ::SelectPalette(pDC->m_hDC, hPal, TRUE);
      ::DeleteObject(hPal);
   }

   if (hdcMemShape)
   {
      DeleteObject(hbmMemShape);
      DeleteDC(hdcMemShape);
   }

   if (hdcMemText)
   {
      DeleteObject(hbmMemText);
      DeleteDC(hdcMemText);
   }
   m_Image.ReleaseDC(pDC);
}