//.....................................................................................................................
//
//  Paint Window : Implementation file.
//
//  Copyright (C) 1990, 1999 LEAD Technologies, Inc.
//  All rights reserved.
//
//.....................................................................................................................

//.....................................................................................................................
// INCLUDES 
//.....................................................................................................................
#include "StdSDK.h"              // Standard application includes
#include "Init.h"         
#include "Frame.h"               
#include "resource.h"            // For resource identifiers
#include "mdi.h"
//#include "error.h"
#include "findwnd.h"
#include "paint.h"

//.....................................................................................................................
// CONSTANTS 
//.....................................................................................................................

//.....................................................................................................................
// TYPES 
//.....................................................................................................................

//.....................................................................................................................
// VARIABLES 
//.....................................................................................................................
extern pAUTOMATIONHANDLE g_pAutomation ;
extern L_CHAR            g_szCurrentText [ 255 ] ;
static HMENU             g_PaintMenu ;
static HMENU             g_PaintContextMenu ;
static HACCEL            g_PaintAccel ;
static HMENU             g_PaintWindowMenu ;

//.....................................................................................................................
// FUNCTIONS
//.....................................................................................................................
LRESULT CALLBACK PaintWndProc ( HWND hWnd, L_UINT message, WPARAM wParam, LPARAM lParam )
{
   switch(message)
   { // MESSAGE 
      
   case WM_CREATE:
      {
         return HANDLE_WM_CREATE ( hWnd, wParam, lParam, Paint_OnCreate ) ;
      }
      
   case WM_DESTROY:
      {
         HANDLE_WM_DESTROY ( hWnd, wParam, lParam, Paint_OnDestroy ) ;
      }
      
      break ;

   case WM_CLOSE:
   case WM_QUERYENDSESSION:
      {
         L_BOOL bRet ; 


         bRet = Paint_OnClose ( hWnd ) ;

         if ( 0 != bRet ) 
         {
            return FALSE ; 
         }
      }

      break ;
      
   case WM_PAINT:
      {
         HANDLE_WM_PAINT ( hWnd, wParam, lParam, Paint_OnPaint ) ;

         return 0 ; 
      }
      
   case WM_COMMAND:
      {
         HANDLE_WM_COMMAND ( hWnd, wParam, lParam, Paint_OnCommand ) ;
      }
      
      return 0 ; 
      
   case WM_SIZE:
      {
         HANDLE_WM_SIZE ( hWnd, wParam, lParam, Paint_OnSize ) ;
      }

      break ; 
      
   case WM_MDIACTIVATE:
      {
         HANDLE_WM_MDIACTIVATE ( hWnd, wParam, lParam, Paint_OnMDIActivate ) ;
      }
      
      break ;
      
   case WM_SETCURSOR:
      {
         HANDLE_WM_SETCURSOR ( hWnd, wParam, lParam, Paint_OnSetCursor ) ;
      }
      
      break ;
      
   case WM_HSCROLL: 
      {
         HANDLE_WM_HSCROLL ( hWnd, wParam, lParam, Paint_OnHScroll ) ; 
      }
      
      break ;
      
   case WM_VSCROLL: 
      {
         HANDLE_WM_VSCROLL ( hWnd, wParam, lParam, Paint_OnVScroll ) ; 
      }
      
      break ;

   case WM_PALETTECHANGED:
      {
         HANDLE_WM_PALETTECHANGED ( hWnd, wParam, lParam, Paint_OnPaletteChanged ) ;
      }
      
      break ;

   case WM_ACTIVATE :   
      if(wParam == WA_INACTIVE)
         break;
   case WM_QUERYNEWPALETTE:
      {
         HANDLE_WM_QUERYNEWPALETTE ( hWnd, wParam, lParam, Paint_OnQueryNewPalette ) ;
      }

      break ;

   case WM_ERASEBKGND:
      {
         return HANDLE_WM_ERASEBKGND ( hWnd, wParam, lParam, Paint_OnEraseBkGnd ) ;
      }

   case WM_CAPTURECHANGED:
      {
         RedrawWindow ( hWnd, 
                        NULL, 
                        NULL, 
                        RDW_ERASE | RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME | RDW_ALLCHILDREN ) ;

         return 0 ; 
      }

   case WM_SYSCOLORCHANGE:
   case WM_DISPLAYCHANGE:   
      {
         Paint_UpdateDisplayData ( hWnd ) ;
      }

      break ;

   case UWM_CONTEXTMENU:
      {
         return HANDLE_WM_CONTEXTMENU ( hWnd, wParam, lParam, Paint_OnContextMenu ) ;
      }
      
      break ;
      
   } // MESSAGE 
   
   return DefMDIChildProc ( hWnd, message, wParam, lParam ) ;
}

L_BOOL Paint_OnInitInstance ( HINSTANCE hinst )
{
   if( ! RegisterMDIChild ( hinst, IDR_PAINT, PaintWndProc, sizeof ( WORD ) ) )
   {
      return FALSE ;
   }
   
   g_PaintMenu = LoadMenu ( hinst, MAKEINTRESOURCE ( IDR_MAINFRAME ) ) ;
   
   g_PaintContextMenu = LoadMenu ( hinst, MAKEINTRESOURCE ( IDR_PAINT_CONTEXT ) ) ;
   
   if ( g_PaintMenu == NULL )
   {
      return FALSE ;
   }
   
   g_PaintAccel = LoadAccelerators ( hinst, MAKEINTRESOURCE ( IDR_PAINT ) ) ;
   
   g_PaintWindowMenu = FindWindowMenu ( g_PaintMenu ) ;
   
   return TRUE ;
}

L_VOID Paint_OnExitInstance ( )
{
   DestroyMenu ( g_PaintMenu ) ;
   DestroyMenu ( g_PaintContextMenu ) ;
}

L_BOOL Paint_OnOpen 
( 
   HWND hWnd, 
   L_TCHAR L_FAR* lpstrFile, 
   L_TCHAR L_FAR* lpstrFileTitle, 
   L_INT nBitmapFormat,
   pBITMAPHANDLE pBitmap 
)
{
   HWND hwndChild ;
   HDC  hdcCompatibility ;
   
   
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   hwndChild = MDI_Create ( g_MDIClientWnd, 
                            MDIS_ALLCHILDSTYLES, 
                            IDR_PAINT, 
                            IDS_PAINT, 
                            0, 
                            0, 
                            1, 
                            1 ) ;
   
   if ( NULL != hwndChild ) 
   {
      pPAINTMDICHILDWNDATA pData ;


      pData = ( pPAINTMDICHILDWNDATA ) malloc ( sizeof ( PAINTMDICHILDWNDATA ) ) ;

      memset ( pData, 0, sizeof ( PAINTMDICHILDWNDATA ) ) ;
      
      if ( pData ) 
      {
         SetWindowLong ( hwndChild, GWL_USERDATA, ( L_UINT32 ) pData ) ; 

         pData->nBitmapFormat = nBitmapFormat ;
         lstrcpy ( pData->lpstrFile, lpstrFile ) ;
         lstrcpy ( pData->lpstrFileTitle, lpstrFileTitle ) ;
         
         hdcCompatibility = GetDC ( hwndChild ) ; 
         
         pData->hBitmap  = *pBitmap ; 
         pData->hPalette = L_CreatePaintPalette ( hdcCompatibility, pBitmap ) ;

         ReleaseDC ( hwndChild, hdcCompatibility ) ;
         
         {//AUTOMATION STUFF
            
            CONTAINERPAINTDATA PaintData ;
            
            
            PaintData.pBitmap             = &pData->hBitmap ;
            PaintData.hRestrictionPalette = pData->hPalette ;
            
            if ( SUCCESS != L_ContainerInit ( &pData->pContainer ) )
            {
               return FALSE ;
            }
            
            if ( SUCCESS != L_ContainerCreate ( pData->pContainer, hwndChild ) )
            {
               return FALSE ;
            }
            
            if ( SUCCESS != L_AutAddContainer ( g_pAutomation, pData->pContainer, &PaintData ) )
            {
               MessageBox ( hwndChild, TEXT("Can't paint to this image."), TEXT("Error:"), MB_OK | MB_ICONSTOP ) ;

               DestroyWindow ( hwndChild ) ;

               return FALSE ;
            }
            
         }//AUTOMATION STUFF
         
         {//ADJUST WINDOW SIZE

            RECT       rcWindow ;
            L_INT      nWidth, nHeight ;
            HDC        dcMDIClient ;
            TEXTMETRIC tm ;
            
            
            GetClientRect ( g_MDIClientWnd, &rcWindow ) ;

            dcMDIClient = GetDC ( g_MDIClientWnd ) ;

            GetTextMetrics ( dcMDIClient, &tm ) ; // calculate the status bar height.

            ReleaseDC ( g_MDIClientWnd, dcMDIClient ) ;
   
            InflateRect ( &rcWindow, - ( 4 * GetSystemMetrics ( SM_CXBORDER ) ), - ( tm.tmHeight + tm.tmExternalLeading ) ) ;

            nWidth  = min ( BITMAPWIDTH  ( pBitmap ), ( rcWindow.right  - rcWindow.left ) ) ;
            nHeight = min ( BITMAPHEIGHT ( pBitmap ), ( rcWindow.bottom - rcWindow.top  ) ) ;

            SetRect ( &rcWindow, 0, 0, nWidth, nHeight ) ;

            AdjustWindowRectEx ( &rcWindow, 
                                 GetWindowLong ( hwndChild, GWL_STYLE ),
                                 FALSE,
                                 GetWindowLong ( hwndChild, GWL_EXSTYLE ) ) ;

            nWidth  = rcWindow.right  - rcWindow.left ;
            nHeight = rcWindow.bottom - rcWindow.top  ;

            MoveWindow ( hwndChild, 
                         0, 
                         0, 
                         nWidth, 
                         nHeight, 
                         TRUE ) ;

         }//ADJUST WINDOW SIZE

         Paint_OnQueryNewPalette ( hwndChild ) ;
         
         return TRUE ; 
      }
      else
      {
         DestroyWindow ( hwndChild ) ;

         return FALSE ;
      }
   }
   else
   {
      return FALSE ;
   }
}

L_BOOL Paint_OnSave ( HWND hWnd ) 
{
   pPAINTMDICHILDWNDATA pData ; 
   L_INT                nRet ;


   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 

   nRet = L_SaveBitmap ( pData->lpstrFile,
                         &pData->hBitmap,
                         pData->nBitmapFormat,
                         pData->hBitmap.BitsPerPixel,
                         2,
                         NULL ) ;   

   if ( SUCCESS == nRet )
   {
      return TRUE ;
   }
   else
   {
      MessageBox ( hWnd, TEXT("Unable to save the file"), TEXT("Error"), MB_OK | MB_ICONSTOP ) ;

      return FALSE ;
   }
}

L_BOOL Paint_OnSaveAs
(
   HWND   hWnd, 
   L_TCHAR L_FAR * plpstrFile, 
   L_INT  nFormat,
   L_INT  nBitsPerPixel, 
   L_INT  nQFactor, 
   pSAVEFILEOPTION pSaveOptions
)
{
   pPAINTMDICHILDWNDATA pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 
   
   return L_SaveBitmap ( plpstrFile,
                         &pData->hBitmap,
                         nFormat,
                         nBitsPerPixel,
                         nQFactor,
                         pSaveOptions ) ;
}

static L_VOID Paint_OnMDIActivate ( HWND hWnd, L_BOOL active, HWND hActivate, HWND hDeactivate )
{
   UNREFERENCED_PARAMETER ( hDeactivate ) ;
   UNREFERENCED_PARAMETER ( hActivate ) ; 
   
   if ( active )
   { // ACTIVATE 
      
      FORWARD_WM_MDISETMENU ( g_MDIClientWnd, TRUE, g_PaintMenu, g_PaintWindowMenu, SendMessage ) ;
      
      SendMessage ( g_hMainFrame, UWM_SET_ACCELERATOR, 0, ( LPARAM ) g_PaintAccel ) ;
      
      DrawMenuBar ( g_hMainFrame )   ;
      
//      PostMessage ( g_hMainFrame, UWM_UPDATE_TOOLBAR, 0, 0 ) ;

      Paint_OnQueryNewPalette ( hWnd ) ;

      
      SetFocus ( hWnd ) ; 
      
   } // ACTIVATE 
   else
   { // DEACTIVATE
      
   } // DEACTIVATE
}

static L_BOOL Paint_OnCreate ( HWND hWnd, LPCREATESTRUCT cs ) 
{
   return FORWARD_WM_CREATE ( hWnd, cs, DefMDIChildProc ) == 0 ;
}

static L_VOID Paint_OnDestroy ( HWND hWnd )
{
   pPAINTMDICHILDWNDATA pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 
   
   
   if ( pData->hBitmap.Flags.Allocated ) 
   {
      L_FreeBitmap ( &pData->hBitmap ) ;
   }
   
   if ( pData->hPalette ) 
   {
      DeletePalette ( pData->hPalette ) ; 
   }
   
   {//AUTOMATION STUFF
      
      L_AutRemoveContainer ( g_pAutomation, pData->pContainer ) ; 
      
      L_ContainerFree ( pData->pContainer ) ;
      
   }//AUTOMATION STUFF
   
   if ( pData ) 
   {
      free ( pData ) ;
      
      pData = NULL ;
   }
   
   PostMessage ( g_hMainFrame, UWM_MDI_DESTROY, 0, 0 ) ;
}

static L_BOOL Paint_OnClose ( HWND hWnd )
{
   pPAINTMDICHILDWNDATA pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 
   L_TCHAR buffer [ MAX_PATH + 20 ] ;
   L_INT nRet ;
   

   wsprintf ( buffer, TEXT("%s %s"), TEXT("Save changes to"), pData->lpstrFile ) ;

   nRet = MessageBox ( hWnd, buffer, TEXT("Warning"), MB_YESNOCANCEL | MB_ICONQUESTION ) ;

   switch ( nRet )
   {
      case IDYES:
         {
            if ( Paint_OnSave ( hWnd ) )
            {
               return 0 ;
            }
         }
      
         break ;
        
      case IDNO:
         {
            return 0 ;
         }

         break ; 

      case IDCANCEL:
         {
            return 1 ;
         }

         break ;
   }

   return 1 ;
}

static L_VOID Paint_OnPaint ( HWND hWnd )
{
   HDC hDC ;
   PAINTSTRUCT ps ; 
   pPAINTMDICHILDWNDATA pData ; 
   HPALETTE hOldPal = NULL ;
   
   
   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 

   hDC = BeginPaint ( hWnd, &ps ) ;
   
   if ( pData->hBitmap.Flags.Allocated ) 
   {
      if ( NULL != pData->hPalette ) 
      {
         hOldPal = SelectPalette ( hDC, pData->hPalette, TRUE ) ;
         RealizePalette ( hDC ) ;
      }

      L_PaintDC ( hDC, &pData->hBitmap, NULL, NULL, &pData->rcView, &ps.rcPaint, SRCCOPY ) ;

      if ( NULL != pData->hPalette ) 
      {
         SelectPalette ( hDC, hOldPal, TRUE ) ;
      }
   }
   
   EndPaint ( hWnd, &ps ) ;
}

static L_VOID Paint_OnCommand ( HWND hWnd, L_INT id, HWND hctl, L_UINT codeNotify )
{
   UNREFERENCED_PARAMETER ( codeNotify ) ;
   UNREFERENCED_PARAMETER ( hctl ) ;
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   switch ( id ) 
   {// id 
   case ID_EDIT_UNDO:
      {
         Paint_OnEditUndo ( hWnd ) ; 
      }
      
      break ;
      
   case ID_EDIT_REDO:
      {
         Paint_OnEditRedo ( hWnd ) ; 
      }
      
      break ;
      
   case ID_EDIT_CUT:
      {
         Paint_OnEditCut ( hWnd ) ; 
      }
      
      break ;
      
   case ID_EDIT_COPY:
      {
         Paint_OnEditCopy ( hWnd ) ; 
      }
      
      break ;
      
   case ID_EDIT_PASTE:
      {
         Paint_OnEditPaste ( hWnd ) ; 
      }
      
      break ;
      
   case ID_EDIT_CLEAR:
      {
         Paint_OnEditDelete ( hWnd ) ; 
      }
      
      break ;
      
   case ID_SELECT_NONE:
      {
         Paint_OnSelectNone ( hWnd ) ;
      }
      
      break ;
      
   case ID_SELECT_ALL:
      {
         Paint_OnSelectAll ( hWnd ) ;
      }
      
      break ;
      
   case ID_FILE_PRINT:
      {
         Paint_OnFilePrint ( hWnd ) ;
      }
      
      break ;
      
   } // id  
}

static L_VOID Paint_OnSize ( HWND hWnd, L_UINT state, L_INT cx, L_INT cy )
{
   pPAINTMDICHILDWNDATA pData ; 
   SCROLLINFO           si ;
   L_INT                nXOffset, nYOffset ;
   L_UINT32             dwStyle ;
   L_INT                nWidth, nHeight ;
   L_INT                nVScroll, nHScroll ;
   L_INT                nScale ;

   
   UNREFERENCED_PARAMETER ( state ) ;

   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ;
   
   if ( pData )
   {	  
      L_ContainerGetScalar ( pData->pContainer, &pData->vptScalarNum, &pData->vptScalarDen ) ; 
   	  
      {//UPDATE ZOOMING FACTOR
      
         L_TCHAR buffer [ MAX_PATH + 10 ] ;

   
         wsprintf ( buffer, TEXT("%s (%d:%d)"), pData->lpstrFileTitle, ( L_INT ) ( L_INT ) pData->vptScalarNum.x, ( L_INT ) ( L_INT ) pData->vptScalarDen.x ) ;
   
         SetWindowText ( hWnd, buffer ) ;
      
      }//UPDATE ZOOMING FACTOR

      if ( pData->vptScalarNum.x <= AUTOMATION_PAINT_MAX_ZOOM )
      {
         nScale = ( L_INT ) ( pData->vptScalarNum.x / pData->vptScalarDen.x ) ;
         
         if ( nScale > 0 )
         {
            cx = ( cx / nScale ) * nScale ; 
            cy = ( cy / nScale ) * nScale ; 
         }
         
         dwStyle = GetWindowLong ( hWnd, GWL_STYLE);
         
         nWidth  = MulDiv ( BITMAPWIDTH  ( &pData->hBitmap ), ( L_INT ) pData->vptScalarNum.x, ( L_INT ) pData->vptScalarDen.x ) ;
         nHeight = MulDiv ( BITMAPHEIGHT ( &pData->hBitmap ), ( L_INT ) pData->vptScalarNum.x, ( L_INT ) pData->vptScalarDen.x ) ;
         
         nVScroll = GetSystemMetrics ( SM_CXVSCROLL ) ;
         nHScroll = GetSystemMetrics ( SM_CYHSCROLL ) ;
         
         if ( WS_VSCROLL & dwStyle )
         {
            cx += nVScroll ;
         }
         
         if ( WS_HSCROLL & dwStyle )
         {
            cy += nHScroll ;
         }
         
         if ( cx < nWidth )
         {
            cy -= nHScroll ;
            
            if ( cy < nHeight )
            {
               cx -= nVScroll ;
            }
         }
         else 
         {
            if ( cy < nHeight )
            {
               cx -= nVScroll ;
               
               if ( cx < nWidth )
               {
                  cy -= nHScroll ;
               }
            }
         }
         
         si.cbSize = sizeof ( SCROLLINFO ) ;
         si.fMask  = SIF_PAGE | SIF_RANGE | SIF_POS ;
         
         // Then the horizontal scroll
         si.nMin  = 0 ;
         si.nMax  = BITMAPWIDTH ( &pData->hBitmap ) - 1 ;
         si.nPage = MulDiv ( cx, ( L_INT ) pData->vptScalarDen.x, ( L_INT ) pData->vptScalarNum.x ) ;
         si.nPos  = pData->nHScroll ; 
         
         pData->nHScroll = SetScrollInfo ( hWnd, SB_HORZ, &si, TRUE ) ; 
         
         // The vertical scroll.
         si.nMin  = 0 ;
         si.nMax  = BITMAPHEIGHT ( &pData->hBitmap ) - 1 ;
         si.nPage = MulDiv ( cy, ( L_INT ) pData->vptScalarDen.x, ( L_INT ) pData->vptScalarNum.x ) ;
         si.nPos  = pData->nVScroll ; 
         
         pData->nVScroll = SetScrollInfo ( hWnd, SB_VERT, &si, TRUE ) ; 
         
         // set the painting rectangel.
         SetRect ( &pData->rcView, 0, 0, BITMAPWIDTH ( &pData->hBitmap ), BITMAPHEIGHT ( &pData->hBitmap ) ) ;
         
         if ( ( pData->vptScalarNum.x / pData->vptScalarDen.x ) < 1 )
         {
            nXOffset = MulDiv ( pData->nHScroll, ( L_INT ) pData->vptScalarDen.x, ( L_INT ) pData->vptScalarNum.x ) ;  
            nYOffset = MulDiv ( pData->nVScroll, ( L_INT ) pData->vptScalarDen.x, ( L_INT ) pData->vptScalarNum.x ) ;
         }
         else
         {
            nXOffset = pData->nHScroll ;  
            nYOffset = pData->nVScroll ;
         }
         
         OffsetRect ( &pData->rcView, - nXOffset, - nYOffset ) ;
         
         pData->rcView.left   = MulDiv ( pData->rcView.left,   ( L_INT ) pData->vptScalarNum.x, ( L_INT ) pData->vptScalarDen.x ) ;
         pData->rcView.top    = MulDiv ( pData->rcView.top,    ( L_INT ) pData->vptScalarNum.x, ( L_INT ) pData->vptScalarDen.x ) ;
         pData->rcView.right  = MulDiv ( pData->rcView.right,  ( L_INT ) pData->vptScalarNum.x, ( L_INT ) pData->vptScalarDen.x ) ;
         pData->rcView.bottom = MulDiv ( pData->rcView.bottom, ( L_INT ) pData->vptScalarNum.x, ( L_INT ) pData->vptScalarDen.x ) ;
         
         {//ADJUST THE CONTAINER OFFSET
            
            L_ContainerSetOffset ( pData->pContainer, - pData->rcView.left, - pData->rcView.top, 0 ) ;
            
         }//ADJUST THE CONTAINER OFFSET
      }
   }
   else
   {
      si.cbSize = sizeof ( SCROLLINFO ) ;
      si.fMask  = SIF_RANGE ;
      si.nMin   = 0 ;   
      si.nMax   = 0 ;
      SetScrollInfo ( hWnd, SB_VERT, &si, TRUE ) ;
      SetScrollInfo ( hWnd, SB_HORZ, &si, TRUE ) ;
   }
}

static L_BOOL Paint_OnSetCursor ( HWND hWnd, HWND hwndCursor, L_UINT codeHitTest, L_UINT msg )
{
   UNREFERENCED_PARAMETER ( hWnd ) ;
   UNREFERENCED_PARAMETER ( hwndCursor ) ;
   UNREFERENCED_PARAMETER ( codeHitTest ) ;
   UNREFERENCED_PARAMETER ( msg ) ;
   
   return FALSE ;
}

static L_VOID Paint_OnHScroll ( HWND hWnd, HWND hCtl, L_UINT code, L_INT pos )
{
   SCROLLINFO si ;
   pPAINTMDICHILDWNDATA pData ; 
   
   
   UNREFERENCED_PARAMETER ( pos ) ;
   UNREFERENCED_PARAMETER ( hCtl ) ;

   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ;

   si.cbSize = sizeof (SCROLLINFO) ;
   si.fMask  = SIF_ALL ;
   GetScrollInfo (hWnd, SB_HORZ, &si) ;
   
   pData->nHScroll = si.nPos ;
   
   switch ( code )
   {
   case SB_LINELEFT:    
      si.nPos -= 1 ;
      break ;
      
   case SB_LINERIGHT:   
      si.nPos += 1 ;
      break ;
      
   case SB_PAGELEFT:    
      si.nPos -= si.nPage ;      
      break ;
      
   case SB_PAGERIGHT:   
      si.nPos += si.nPage ;      
      break ;
      
   case SB_THUMBTRACK:  
      si.nPos = si.nTrackPos ; 
      break ;
      
   default:                                        
      break ;
   }
   
   si.fMask = SIF_POS ;
   SetScrollInfo (hWnd, SB_HORZ, &si, TRUE) ;
   GetScrollInfo (hWnd, SB_HORZ, &si) ;
   
   if ( si.nPos != pData->nHScroll )
   {
      L_INT dxUpdate ;
      
      
      // update screen.
      if ( ( pData->vptScalarNum.x / pData->vptScalarDen.x ) > 1 )
      {
         dxUpdate = MulDiv ( ( pData->nHScroll - si.nPos ), ( L_INT ) pData->vptScalarNum.x, ( L_INT ) pData->vptScalarDen.x ) ;
      }
      else
      {
         dxUpdate = pData->nHScroll - si.nPos ;
      }

      OffsetRect ( &pData->rcView, dxUpdate, 0 ) ;
      ScrollWindowEx ( hWnd, dxUpdate, 0, NULL, NULL, NULL, NULL, SW_INVALIDATE | SW_ERASE ) ;
      pData->nHScroll = si.nPos ;

      {//ADJUST THE CONTAINER OFFSET
         
         L_ContainerSetOffset ( pData->pContainer, - pData->rcView.left, - pData->rcView.top, 0 ) ;
         
      }//ADJUST THE CONTAINER OFFSET

      UpdateWindow ( hWnd ) ;
   }
}

static L_VOID Paint_OnVScroll ( HWND hWnd, HWND hCtl, L_UINT code, L_INT pos )
{
   SCROLLINFO si ;
   pPAINTMDICHILDWNDATA pData ; 
   
   
   UNREFERENCED_PARAMETER ( pos ) ;
   UNREFERENCED_PARAMETER ( hCtl ) ; 
   
   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ;

   si.cbSize = sizeof (SCROLLINFO) ;
   si.fMask  = SIF_ALL ;
   GetScrollInfo ( hWnd, SB_VERT, &si ) ;
   
   pData->nVScroll = si.nPos ;
   
   switch ( code )
   {
   case SB_LINEUP:
      si.nPos -= 1 ;
      break ;
      
   case SB_LINEDOWN:
      si.nPos += 1 ;
      break ;
      
   case SB_PAGEUP:
      si.nPos -= si.nPage ;      
      break ;
      
   case SB_PAGEDOWN:
      si.nPos += si.nPage ;      
      break ;
      
   case SB_THUMBTRACK:  
      si.nPos = si.nTrackPos ; 
      break ;
      
   default:
      break ;
   }
   
   si.fMask = SIF_POS ;
   SetScrollInfo ( hWnd, SB_VERT, &si, TRUE ) ;
   GetScrollInfo ( hWnd, SB_VERT, &si ) ;
   
   if ( si.nPos != pData->nVScroll )
   {
      L_INT dyUpdate ;
      
    
      if ( ( pData->vptScalarNum.x / pData->vptScalarDen.x ) > 1 )
      {
         dyUpdate = MulDiv ( ( pData->nVScroll - si.nPos ), ( L_INT ) pData->vptScalarNum.x, ( L_INT ) pData->vptScalarDen.x ) ;
      }
      else
      {
         dyUpdate = ( pData->nVScroll - si.nPos ) ;
      }
      
      // update screen.
      OffsetRect ( &pData->rcView, 0, dyUpdate ) ;
      ScrollWindowEx ( hWnd, 0, dyUpdate, NULL, NULL, NULL, NULL, SW_INVALIDATE | SW_ERASE ) ;
      pData->nVScroll = si.nPos ;

      {//ADJUST THE CONTAINER OFFSET
         
         L_ContainerSetOffset ( pData->pContainer, - pData->rcView.left, - pData->rcView.top, 0 ) ;
         
      }//ADJUST THE CONTAINER OFFSET

      UpdateWindow ( hWnd ) ;
   }
}

static L_VOID Paint_OnPaletteChanged ( HWND hWnd, HWND hwndPaletteChange ) 
{
   pPAINTMDICHILDWNDATA pData ;
   HDC hDC ; 
   HPALETTE hOldPal ; 
   
   
   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 

   if ( NULL != pData )
   {
      if ( hWnd != hwndPaletteChange )  
      {  
         if ( NULL == pData->hPalette  )
         {
            DeleteObject(pData->hPalette);
            pData->hPalette=NULL;
         }
         
         hDC = GetDC ( hWnd ) ;

         pData->hPalette = L_CreatePaintPalette(hDC,&pData->hBitmap);
      
         if ( NULL != pData->hPalette )
         {
            hOldPal = SelectPalette ( hDC, pData->hPalette, TRUE ) ;
            RealizePalette ( hDC ) ;
     
            SelectPalette ( hDC, hOldPal, TRUE ) ;
         }

         ReleaseDC ( hWnd, hDC ) ;

         if ( NULL != pData->hPalette )
         {
            InvalidateRect ( hWnd, NULL, FALSE ) ;
            UpdateWindow ( hWnd ) ;
         }
      } 
   }
}

static L_BOOL Paint_OnQueryNewPalette ( HWND hWnd ) 
{
   pPAINTMDICHILDWNDATA pData ;
   HDC                  hDC ; 
   HPALETTE             hOldPal ; 
   
   
   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 

   if ( NULL != pData )
   {
      hDC = GetDC ( hWnd ) ;

      if ( NULL == pData->hPalette  )
      {
         DeleteObject(pData->hPalette);
         pData->hPalette=NULL;
      }
      pData->hPalette = L_CreatePaintPalette(hDC,&pData->hBitmap);
      if ( NULL != pData->hPalette  )
      {
         hOldPal = SelectPalette ( hDC, pData->hPalette, FALSE ) ;
         RealizePalette ( hDC ) ;
   
         SelectPalette ( hDC, hOldPal, TRUE ) ;
      }

      ReleaseDC ( hWnd, hDC ) ;

      if ( NULL != pData->hPalette )
      {
         InvalidateRect ( hWnd, NULL, FALSE ) ;
         UpdateWindow ( hWnd ) ;
      }
   }

   return TRUE ;
}

L_BOOL Paint_OnEraseBkGnd ( HWND hWnd, HDC hDC ) 
{
   HRGN hrgnView   = NULL ;
   HRGN hrgnClient = NULL ;
   RECT rcClient ; 
   pPAINTMDICHILDWNDATA pData ; 
   HBRUSH hbrBack ;


   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 

   if ( NULL != pData )
   {
      GetClientRect ( hWnd, &rcClient ) ;

      hrgnView   = CreateRectRgn ( pData->rcView.left, pData->rcView.top, pData->rcView.right, pData->rcView.bottom ) ;
      hrgnClient = CreateRectRgn ( rcClient.left, rcClient.top, rcClient.right, rcClient.bottom ) ;

      hbrBack = CreateSolidBrush ( GetSysColor ( COLOR_WINDOW ) ) ;

      CombineRgn ( hrgnView, hrgnClient, hrgnView, RGN_XOR ) ;

      SaveDC ( hDC ) ;

      SelectClipRgn ( hDC, hrgnView ) ;

      FillRect ( hDC, &rcClient, hbrBack ) ;

      RestoreDC ( hDC, -1 ) ;

      DeleteRgn   ( hrgnView ) ;
      DeleteRgn   ( hrgnClient ) ;
      DeleteBrush ( hbrBack ) ;

      return TRUE ; 
   }
   else
   {
      return FALSE ;
   }
}

static L_VOID Paint_OnEditUndo ( HWND hWnd )
{
   L_BOOL fCanUndo ;
   
   
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   L_AutCanUndo ( g_pAutomation, &fCanUndo ) ;
   
   if ( fCanUndo ) 
   {
      L_AutUndo ( g_pAutomation, 0 ) ;
   }
}

static L_VOID Paint_OnEditRedo ( HWND hWnd )
{   
   L_BOOL fCanRedo ;
   
   
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   L_AutCanRedo ( g_pAutomation, &fCanRedo ) ;
   
   if ( fCanRedo ) 
   {
      L_AutRedo ( g_pAutomation, 0 ) ;
   }
}

static L_VOID Paint_OnEditCut ( HWND hWnd )
{
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   
   L_AutCut ( g_pAutomation, 0 ) ;
}

static L_VOID Paint_OnEditCopy ( HWND hWnd ) 
{
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   
   L_AutCopy ( g_pAutomation, 0 ) ;
}

static L_VOID Paint_OnEditPaste ( HWND hWnd )
{
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   
   L_AutPaste ( g_pAutomation, 0 ) ;
}

static L_VOID Paint_OnEditDelete ( HWND hWnd )
{
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   
   L_AutDelete ( g_pAutomation, 0 ) ;
}

static L_VOID Paint_OnSelectNone ( HWND hWnd )
{
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   
   L_AutSelect ( g_pAutomation, AUTOMATION_SELECT_NONE, 0 ) ;
}

static L_VOID Paint_OnSelectAll ( HWND hWnd )
{
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   
   L_AutSelect ( g_pAutomation, AUTOMATION_SELECT_ALL, 0 ) ;
}

static L_VOID Paint_OnFilePrint ( HWND hWnd )
{
   UNREFERENCED_PARAMETER ( hWnd ) ;
   
   
   L_AutPrint ( g_pAutomation, 0 ) ;
}

static L_BOOL Paint_OnContextMenu ( HWND hWnd, HWND hwndCtl, L_INT xPos, L_INT yPos )
{
   return MDI_OnContextMenu ( hWnd, hwndCtl, xPos, yPos, g_PaintContextMenu ) ;
}


L_BOOL Paint_UpdateDisplayData ( HWND hWnd )
{
   pPAINTMDICHILDWNDATA pData ; 
   HDC                  hdcCompatibility ;


   pData = ( pPAINTMDICHILDWNDATA ) ( L_UINT32 ) GetWindowLong ( hWnd, GWL_USERDATA ) ; 

   if ( pData ) 
   {
      hdcCompatibility = GetDC ( hWnd ) ; 

      if ( pData->hPalette ) 
      {
         DeletePalette ( pData->hPalette ) ;

         pData->hPalette = NULL ;
      }

      pData->hPalette = L_CreatePaintPalette ( hdcCompatibility, &pData->hBitmap ) ;

      ReleaseDC ( hWnd, hdcCompatibility ) ;
   }

   InvalidateRect ( hWnd, NULL, TRUE ) ;
   UpdateWindow ( hWnd ) ;

   return TRUE ;
}