// MainFrm.cpp : implementation of the CMainFrame class
//

#include "stdafx.h"
#include "Overlay.h"

#include "MainFrm.h"
#include "LeftPaneWnd.h"
#include "RightPaneWnd.h"
#include "OverlayAttribDlg.h" 

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include "OverlayView.h"

#ifndef RECTWIDTH
#define RECTWIDTH(p) (((LPRECT) (p))->right - ((LPRECT) (p))->left)
#endif

#ifndef RECTHEIGHT
/* ABS() is used because a PM rect top and bottom are reversed from Windows */
#define RECTHEIGHT(p) abs(((LPRECT) (p))->bottom - ((LPRECT) (p))->top)
#endif

/////////////////////////////////////////////////////////////////////////////
// CMainFrame

IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
   //{{AFX_MSG_MAP(CMainFrame)
   ON_WM_CREATE()
   ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
   ON_WM_SIZE()
   ON_COMMAND(ID_OVERLAYS_CHANGEOVERLAYCOLOR, OnOverlaysChangeOverlayColor)
   ON_COMMAND(ID_OVERLAYS_SAVEOVERLAY, OnOverlaysSaveOverlay)
   ON_COMMAND(ID_OVERLAYS_SHOWOVERLAYATTRIBUTES, OnOverlaysShowOverlayAttributes)
   ON_COMMAND(ID_OVERLAYS_SHOWOVERLAY, OnOverlaysShowOverlay)
   ON_UPDATE_COMMAND_UI(ID_OVERLAYS_SHOWOVERLAY, OnUpdateOverlaysShowOverlay)
   ON_COMMAND(ID_OVERLAYS_INSERTOVERLAY, OnOverlaysInsertOverlay)
   ON_UPDATE_COMMAND_UI(ID_OVERLAYS_INSERTOVERLAY, OnUpdateOverlaysInsertOverlay)
   ON_UPDATE_COMMAND_UI(ID_OVERLAYS_SHOWOVERLAYATTRIBUTES, OnUpdateOverlaysShowOverlayAttributes)
   ON_UPDATE_COMMAND_UI(ID_OVERLAYS_SAVEOVERLAY, OnUpdateOverlaysSaveOverlay)
   ON_UPDATE_COMMAND_UI(ID_OVERLAYS_CHANGEOVERLAYCOLOR, OnUpdateOverlaysChangeOverlayColor)
   ON_COMMAND(ID_FILE_SAVE_FILE, OnFileSaveFile)
   ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_FILE, OnUpdateFileSaveFile)
   ON_WM_PALETTECHANGED()
   ON_WM_QUERYNEWPALETTE()
   ON_WM_SYSCOLORCHANGE()
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

static UINT indicators[] =
{
   ID_SEPARATOR,           // status line indicator
   ID_INDICATOR_CAPS,
   ID_INDICATOR_NUM,
   ID_INDICATOR_SCRL,
};

/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction

CMainFrame::CMainFrame()
{
   LBase::LoadLibraries(LT_ALL_LEADLIB);
   WRPUNLOCKSUPPORT();

   m_hCtl          = NULL;
   m_nSelItemIndex = 0;
   m_bShowOverlay  = FALSE;
   m_uCount        = 0;
   m_pElement      = NULL;

   memset (m_szFileName, 0, sizeof (m_szFileName));

   LDialogBase::Initialize(DLG_INIT_COLOR);
}

CMainFrame::~CMainFrame()
{
   m_DS.ResetDS();
   LBase::UnloadLibraries(LT_ALL_LEADLIB);
   LDialogBase::Free();
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
   if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
      return -1;

   if (!m_wndStatusBar.Create(this) ||
       !m_wndStatusBar.SetIndicators(indicators,
       sizeof(indicators)/sizeof(UINT)))
   {
      TRACE0("Failed to create status bar\n");
      return -1;      // fail to create
   }

   return 0;
}

BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT /*lpcs*/, CCreateContext* pContext)
{
   if (!m_wndSplitter.CreateStatic(this, 1, 2))
   {
      TRACE0("Failed to create splitter window\n");
      return FALSE;
   }

   CRect rect;
   GetClientRect(&rect);

   if (!m_wndSplitter.CreateView(0, 0, RUNTIME_CLASS(CLeftPaneWnd), CSize(180, 0), pContext))
   {
      TRACE0("Failed to create left pane view\n");
      return FALSE;
   }

   if (!m_wndSplitter.CreateView(0, 1, RUNTIME_CLASS(CRightPaneWnd), CSize(0, 0), pContext))
   {
      TRACE0("Failed to create right pane frame\n");
      return FALSE;
   }

   // Set the left pane as the active view
   SetActiveView((CView*) m_wndSplitter.GetPane(0, 0));
   return TRUE;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
   cs.style = WS_OVERLAPPEDWINDOW | WS_CAPTION;
   cs.lpszName = "Overlay Classlib Demo";

   if( !CFrameWnd::PreCreateWindow(cs) )
      return FALSE;
   // TODO: Modify the Window class or styles here by modifying
   //  the CREATESTRUCT cs

   return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
   CFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
   CFrameWnd::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers


void CMainFrame::OnFileOpen() 
{
   OVERLAYATTRIBUTES    OverlayAttributes;
   L_INT                i;

   CRightPaneWnd* pRightPane = (CRightPaneWnd*)m_wndSplitter.GetPane(0, 1);
   CLeftPaneWnd*  pLeftPane = (CLeftPaneWnd*)m_wndSplitter.GetPane(0, 0);
   LPSTR pszFilter = "Dicom files(*.dic)|*.dic|";

   TCHAR szFilters[] =_T ("DICOM Files (*.dic)|*.dic|DCM Files (*.dcm)|*.dcm|All files (*.*)|*.*||");
   CFileDialog dlg ( TRUE, 
                     _T ("dic"), 
                     _T ("*.dic"),
                     OFN_FILEMUSTEXIST | OFN_HIDEREADONLY, 
                     szFilters);
   
   if (dlg.DoModal () != IDOK) 
   {
      return;   
   }

   strcpy (m_szFileName, (L_CHAR *)(LPCSTR)dlg.GetPathName());
   pRightPane->m_LBitmapWnd.SetFileName (m_szFileName);
   if (pRightPane->m_LBitmapWnd.IsAllocated())
   {
      pRightPane->m_LBitmapWnd.Free();
   }

   if (m_hCtl == NULL)
   {
      /* Create the LEAD ImageList Control */
      if (CreateLEADImageList () != SUCCESS)
      {
         MessageBox(TEXT("Error creating image list control"), TEXT("Error"), MB_OK);
         return;
      }
   }

   if (pLeftPane->LoadOverlays () != SUCCESS)
      return;

   m_bShowOverlay = TRUE;
   /* Make the OVERLAY_AUTOPAINT flag always on to automaticaly paint the overlays
      over the original image */
   memset (&OverlayAttributes, 0, sizeof (OVERLAYATTRIBUTES));
   L_UINT uFlags = OVERLAYATTRIBUTES_FLAGS | OVERLAYATTRIBUTES_ORIGIN;
   for(i = 0; i < (L_INT)m_uCount; i++)
   {
      L_INT nRet = m_LeadBitmap.GetOverlayAttributes(i, &OverlayAttributes, sizeof(OVERLAYATTRIBUTES), uFlags);
      if (!OverlayAttributes.uFlags & OVERLAY_AUTOPAINT )
      {
         OverlayAttributes.uFlags |= OVERLAY_AUTOPAINT;
         m_LeadBitmap.SetOverlayAttributes(i, &OverlayAttributes, uFlags);
      }
   }
}

L_INT CMainFrame::CreateLEADImageList()
{
   RECT           rcWin;
   L_UINT32       uFlags;
   LILSELOPTION   Opt;
   LILITEMOPTION  MOpt;

   CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->GetMainWnd();
   CRightPaneWnd* pRightPane = (CRightPaneWnd*)m_wndSplitter.GetPane(0, 1);
   m_hLeftPaneWnd = m_wndSplitter.GetPane(0, 0)->m_hWnd;

   ::GetClientRect(m_hLeftPaneWnd, &rcWin);

   m_hCtl = m_ImgList.CreateControl(m_hLeftPaneWnd, 
                                    IDC_IMGLISTCTRL,
                                    WS_CHILD|WS_VISIBLE|WS_BORDER,
                                    0,
                                    0,
                                    RECTWIDTH(&rcWin),
                                    RECTHEIGHT(&rcWin),
                                    RGB(128,128,128));

   if(!IsWindow(m_hCtl))
   {
      return 0;
   }

   uFlags = pRightPane->m_LBitmapWnd.GetDisplayMode();
   uFlags |= DISPLAYMODE_RESAMPLE | DISPLAYMODE_SCALETOGRAY;
   m_ImgList.SetDisplayFlags(uFlags);

   // Enable / Disable selection style & method
   memset (&Opt, 0, sizeof (LILSELOPTION));
   Opt.uStructSize = sizeof(LILSELOPTION);
   m_ImgList.GetSelectionOptions(&Opt);
   Opt.uAllowSelection = ALLOWSELECTION_SINGLE;
   Opt.uSelectionStyle = SELECTIONSTYLE_PRESSEDBUTTON;
   m_ImgList.SetSelectionOptions(&Opt);

   // Enable / Disable display text, and change the item size
   memset(&MOpt, 0, sizeof(MOpt));
   MOpt.uStructSize = sizeof(LILITEMOPTION);
   m_ImgList.GetItemOptions(&MOpt);
   MOpt.bDisplayItemText = TRUE;
   MOpt.uWidth  = 145;
   MOpt.uHeight =  145;
   m_ImgList.SetItemOptions(&MOpt);

   // Enable / Disable keyboard
   m_ImgList.EnableKeyboard(TRUE);

   // Set scroll style Vert / Horz
   m_ImgList.SetScrollStyle(SCROLLSTYLE_VERTICAL);

   ::SetFocus(m_hCtl);
   return 1;
}

void CMainFrame::OnSize(UINT nType, int cx, int cy) 
{
   CFrameWnd::OnSize(nType, cx, cy);

   RECT rcWin;

   ::GetClientRect(m_hLeftPaneWnd, &rcWin);
   ::MoveWindow(m_hCtl, 0, 0, RECTWIDTH(&rcWin), RECTHEIGHT(&rcWin), TRUE);
}

void CMainFrame::OnOverlaysChangeOverlayColor() 
{
   OVERLAYATTRIBUTES OverlayAttributes;
   COLORDLGPARAMS    ColorDlg;
   BITMAPHANDLE      OverlayBitmap;
   LBitmap           TmpLeadBitmap;
   LILITEM           Item;
   L_INT             nRet;
   RGBQUAD           aPalette[2];

   CRightPaneWnd* pRightPane = (CRightPaneWnd*)m_wndSplitter.GetPane(0, 1);

   memset (&ColorDlg, 0, sizeof (COLORDLGPARAMS));
   ColorDlg.uStructSize = sizeof (COLORDLGPARAMS);
   ColorDlg.uDlgFlags   = DLG_COLOR_SHOW_CONTEXTHELP           |
                          DLG_COLOR_SHOW_OLDCOLOR              |
                          DLG_COLOR_SHOW_NEWCOLOR              |
                          DLG_COLOR_SHOW_NAME                  |
                          DLG_COLOR_COLORSPACE_SHOW_HUE        |
                          DLG_COLOR_COLORSPACE_SHOW_BRIGHTNESS |
                          DLG_COLOR_COLORSPACE_SHOW_WHEEL      |
                          DLG_COLOR_COLORSPACE_SHOW_RGB        |
                          DLG_COLOR_COLORSPACE_SHOW_CMY        |
                          DLG_COLOR_COLORSPACE_SHOW_CMYK       |
                          DLG_COLOR_COLORSPACE_SHOW_LAB        |
                          DLG_COLOR_COLORMODEL_SHOW_RGB        |
                          DLG_COLOR_COLORMODEL_SHOW_HSB        |
                          DLG_COLOR_COLORMODEL_SHOW_HLS        |
                          DLG_COLOR_COLORMODEL_SHOW_CMY        |
                          DLG_COLOR_COLORMODEL_SHOW_CMYK       |
                          DLG_COLOR_COLORMODEL_SHOW_LAB;

   pRightPane->m_LBitmapWnd.DialogColor()->SetColorParams(&ColorDlg);
   if (pRightPane->m_LBitmapWnd.DialogColor()->DoModalColor(pRightPane->m_hWnd) != SUCCESS_DLG_OK)
      return;

   pRightPane->m_LBitmapWnd.DialogColor()->GetColorParams(&ColorDlg, sizeof (ColorDlg));
   nRet = m_LeadBitmap.GetOverlayAttributes(m_nSelItemIndex, &OverlayAttributes, sizeof(OVERLAYATTRIBUTES), OVERLAYATTRIBUTES_COLOR);
   OverlayAttributes.crColor = ColorDlg.crColor;
   nRet = m_LeadBitmap.SetOverlayAttributes(m_nSelItemIndex, &OverlayAttributes, OVERLAYATTRIBUTES_COLOR);

   // Update the overlay preview with the new color
   memset (&OverlayBitmap, 0, sizeof (BITMAPHANDLE));
   memset (&Item, 0, sizeof (LILITEM));
   nRet = m_LeadBitmap.GetOverlay(m_nSelItemIndex, &OverlayBitmap, sizeof (BITMAPHANDLE), OVERLAY_COPY);

   memset(aPalette, 0, sizeof(RGBQUAD)); // set first entry to all 0
   aPalette[1].rgbRed   = GetRValue(OverlayAttributes.crColor);
   aPalette[1].rgbGreen = GetGValue(OverlayAttributes.crColor);
   aPalette[1].rgbBlue  = GetBValue(OverlayAttributes.crColor);
   // Make the overlay preview looks clearer
   TmpLeadBitmap.SetHandle(&OverlayBitmap, TRUE);
   
   TmpLeadBitmap.GetColors(0, 2, aPalette); 
   
   aPalette[1].rgbRed   = GetRValue(OverlayAttributes.crColor);
   aPalette[1].rgbGreen = GetGValue(OverlayAttributes.crColor);
   aPalette[1].rgbBlue  = GetBValue(OverlayAttributes.crColor);

   TmpLeadBitmap.PutColors(0, 2, aPalette); 

   TmpLeadBitmap.Size(140, 140, SIZE_FAVORBLACK);   

   Item.uStructSize = sizeof (LILITEM);
   Item.uBitmapStructSize = sizeof (BITMAPHANDLE);
   Item.uMask = LILITEM_BITMAP;
   m_ImgList.GetItem (&Item, m_nSelItemIndex);
   Item.pBitmap = TmpLeadBitmap.GetHandle();
   m_ImgList.Update(&Item, m_nSelItemIndex);

   pRightPane->m_LBitmapWnd.Repaint(NULL);
}

void CMainFrame::OnUpdateOverlaysChangeOverlayColor(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable (m_uCount > 0 ? TRUE : FALSE);
}

void CMainFrame::OnOverlaysSaveOverlay() 
{
   SAVEFILEOPTION SaveFileOptions;
   L_CHAR         szSaveFileName[_MAX_PATH];
   BITMAPHANDLE   OverlayBitmap;
   LBitmap        TmpLeadBitmap;
   L_INT          nRet;

   CFileDialog SaveDlg( FALSE, "bmp", NULL, OFN_OVERWRITEPROMPT, "Windows Bitmap (*.bmp)|*.bmp|");
   if (SaveDlg.DoModal()!=IDOK)
      return;

   memset (&szSaveFileName, 0, sizeof (&szSaveFileName));
   strcpy (szSaveFileName, SaveDlg.GetPathName().GetBuffer(SaveDlg.GetPathName().GetLength()));

   memset (&OverlayBitmap, 0, sizeof (BITMAPHANDLE));
   nRet = m_LeadBitmap.GetOverlay(m_nSelItemIndex, &OverlayBitmap, sizeof (BITMAPHANDLE), OVERLAY_COPY);
   if(nRet == SUCCESS)
   {
      TmpLeadBitmap.SetHandle(&OverlayBitmap);
      TmpLeadBitmap.File()->GetDefaultSaveFileOption(&SaveFileOptions, sizeof (SAVEFILEOPTION));
      nRet = TmpLeadBitmap.Save(szSaveFileName, FILE_BMP, 1, 2, 0, &SaveFileOptions);
      if (nRet != SUCCESS)
         MessageBox ("Error saving overlay bitmap.", "Error", MB_OK|MB_ICONERROR);
   }
   else
   {
      MessageBox ("Error saving overlay bitmap.", "Error", MB_OK|MB_ICONERROR);
   }
}

void CMainFrame::OnUpdateOverlaysSaveOverlay(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable (m_uCount > 0 ? TRUE : FALSE);
}

void CMainFrame::OnOverlaysShowOverlayAttributes() 
{
   COverlayAttribDlg* pOverlayAttribDlg = new COverlayAttribDlg(this);

   pOverlayAttribDlg->DoModal();
}

void CMainFrame::OnUpdateOverlaysShowOverlayAttributes(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable (m_uCount > 0 ? TRUE : FALSE);
}

void CMainFrame::OnOverlaysShowOverlay() 
{
   OVERLAYATTRIBUTES OverlayAttributes;
   L_UINT            uFlags = OVERLAYATTRIBUTES_FLAGS | OVERLAYATTRIBUTES_ORIGIN;
   L_INT             nRet;

   m_bShowOverlay = !m_bShowOverlay;

   CRightPaneWnd* pRightPane = (CRightPaneWnd*)m_wndSplitter.GetPane(0, 1);
   memset (&OverlayAttributes, 0, sizeof (OverlayAttributes));
   nRet = m_LeadBitmap.GetOverlayAttributes(m_nSelItemIndex, &OverlayAttributes, sizeof(OVERLAYATTRIBUTES), uFlags);
   if (m_bShowOverlay)
      OverlayAttributes.uFlags |= OVERLAY_AUTOPAINT;
   else
      OverlayAttributes.uFlags &= ~OVERLAY_AUTOPAINT;

   m_LeadBitmap.SetOverlayAttributes (m_nSelItemIndex, &OverlayAttributes, uFlags);
   pRightPane->m_LBitmapWnd.Repaint(NULL);
}

void CMainFrame::OnUpdateOverlaysShowOverlay(CCmdUI* pCmdUI) 
{
   if (m_uCount > 0)
   {
      pCmdUI->Enable (TRUE);
      pCmdUI->SetCheck (m_bShowOverlay ? TRUE : FALSE);
   }
   else
      pCmdUI->Enable (FALSE);
}

void CMainFrame::OnOverlaysInsertOverlay() 
{
   OVERLAYATTRIBUTES OverlayAttributes;
   LPSTR             pszFilter = "All files(*.*)|*.*|";
   L_CHAR            szFileName[_MAX_PATH];
   L_CHAR            szItemText[20];
   LILITEM           Item, OldSelectItem;
   L_INT             nRet;
   LBitmap           LeadBitmap;

   CRightPaneWnd* pRightPane = (CRightPaneWnd*)m_wndSplitter.GetPane(0, 1);

   memset (&szFileName, 0, sizeof (szFileName));
   memset (&szItemText, 0, sizeof (szItemText));
   memset (&Item, 0, sizeof (LILITEM));

   CFileDialog OpenDlg( TRUE, NULL, NULL, OFN_FILEMUSTEXIST, pszFilter);
   if (OpenDlg.DoModal()!=IDOK)
      return;

   // Load the overlay bitmap
   strcpy (szFileName, OpenDlg.GetPathName().GetBuffer(OpenDlg.GetPathName().GetLength()));
   nRet = LeadBitmap.Load(szFileName, 1, ORDER_RGBORGRAY, 0, NULL);
   if(nRet != SUCCESS)
   {
      MessageBox ("Error loading bitmap.", "Error", MB_OK|MB_ICONERROR);
      return;
   }

   // Turn the OVERLAY_AUTOPAINT flag on.
   memset (&OverlayAttributes, 0, sizeof (OVERLAYATTRIBUTES));

   OverlayAttributes.uStructSize          = sizeof(OVERLAYATTRIBUTES);
   OverlayAttributes.ptOrigin.y           = 0;
   OverlayAttributes.ptOrigin.x           = 0;
   OverlayAttributes.crColor              = RGB(0xFF,0xFF,0xFF);
   OverlayAttributes.uRows                = LeadBitmap.GetHeight();
   OverlayAttributes.uColumns             = LeadBitmap.GetWidth();
   OverlayAttributes.uBitsAllocated       = 1;
   OverlayAttributes.nNumFramesInOverlay  = 1;
   OverlayAttributes.uImageFrameOrigin    = 1;
   OverlayAttributes.uFlags |= OVERLAY_AUTOPAINT|OVERLAY_AUTOPROCESS;
   strcpy(OverlayAttributes.szType,"G");

   nRet = m_LeadBitmap.SetOverlayAttributes( m_uCount, 
                                             &OverlayAttributes, 
                                             OVERLAYATTRIBUTES_FLAGS    |
                                             OVERLAYATTRIBUTES_ORIGIN   |
                                             OVERLAYATTRIBUTES_DICOM    |
                                             OVERLAYATTRIBUTES_COLOR);
   if(nRet == SUCCESS)
   {
      nRet = m_LeadBitmap.SetOverlay(m_uCount, &LeadBitmap, OVERLAY_COPY);
      if(nRet != SUCCESS)
      {
         MessageBox ("Error inserting overlay bitmap.", "Error", MB_OK|MB_ICONERROR);
         m_LeadBitmap.Free();
         return;
      }
   }
   else
   {
      MessageBox ("Error setting overlay attributes", "Error", MB_OK|MB_ICONERROR);
      m_LeadBitmap.Free();
      return;
   }

  pRightPane->m_LBitmapWnd.Repaint();
   /* Remove selection from the selected image list item to select 
      the new one that will be added */
   memset (&OldSelectItem, 0, sizeof (LILITEM));
   OldSelectItem.uStructSize = sizeof (LILITEM);
   OldSelectItem.uBitmapStructSize = sizeof (BITMAPHANDLE);
   OldSelectItem.uMask = LILITEM_SELECTED;
   m_ImgList.GetSelectedItems(&OldSelectItem);
   OldSelectItem.bSelected = FALSE;
   m_ImgList.Update(&OldSelectItem, OldSelectItem.lIndex);

   // Add the new overlay to the image list
   memset (&Item, 0, sizeof (LILITEM));
   Item.uStructSize        = sizeof (LILITEM);
   Item.uBitmapStructSize  = sizeof (BITMAPHANDLE);
   Item.pTextExt           = m_szFileName;
   Item.lData              = 1;
   Item.uMask              = LILITEM_ALL;
   Item.pBitmap            = LeadBitmap.GetHandle();
   sprintf (szItemText, "Overlay %d", m_uCount);
   Item.pText              = szItemText;
   Item.bSelected          = TRUE;
   m_ImgList.Insert(&Item, -1);
   m_ImgList.EnsureVisible(m_ImgList.GetItemCount()-1);

   m_nSelItemIndex = Item.lIndex;
   m_uCount++;
}

void CMainFrame::OnUpdateOverlaysInsertOverlay(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable (m_uCount > 0 ? TRUE : FALSE);
}

void CMainFrame::OnFileSaveFile() 
{
   DICOMIMAGE     Info;
   L_CHAR         szSaveFileName[_MAX_PATH];
   L_UINT16       uRet;

   TCHAR szFilters[] =_T ("DICOM Files (*.dic)|*.dic|All files (*.*)|*.*||");

   CFileDialog dlg ( FALSE,
                     _T ("dic"), 
                     _T ("*.dic"),
                     OFN_OVERWRITEPROMPT, 
                     szFilters);
   // Get file name
   if (dlg.DoModal () != IDOK) 
   {
      return;   
   }

   memset (&szSaveFileName, 0, sizeof (&szSaveFileName));
   memset (&Info, 0, sizeof (DICOMIMAGE));

   strcpy (szSaveFileName, (L_CHAR *)(LPCTSTR)dlg.GetPathName());

   uRet = m_DS.GetInfoImage(m_pElement, &Info, TRUE);
   uRet = m_DS.SetImage ( NULL, 
                          m_LeadBitmap.GetHandle(), 
                          Info.nCompression,
                          Info.nPhotometric, 
                          0, 0, 
                          DICOM_SETIMAGE_AUTO_SAVE_OVERLAYS,
                          NULL, 
                          NULL);

   if (uRet != DICOM_SUCCESS)
   {
      MessageBox ("Error saving overlay bitmap.", "Error", MB_OK|MB_ICONERROR);
      return;
   }

   uRet = m_DS.SaveDS (szSaveFileName, 0);
   if (uRet != DICOM_SUCCESS)
      MessageBox ("Error saving data set.", "Error", MB_OK|MB_ICONERROR);
}

void CMainFrame::OnUpdateFileSaveFile(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable (m_uCount > 0 ? TRUE : FALSE);
}

void CMainFrame::OnPaletteChanged(CWnd* pFocusWnd) 
{
   CFrameWnd::OnPaletteChanged(pFocusWnd);

   // TODO: Add your message handler code here
   CRightPaneWnd* pCView = ( CRightPaneWnd* ) GetActiveView();
   if (pCView)
      pCView->m_LBitmapWnd.HandlePalette(WM_PALETTECHANGED,(WPARAM)pFocusWnd->m_hWnd, 0);
}

BOOL CMainFrame::OnQueryNewPalette() 
{
   // TODO: Add your message handler code here and/or call default
   CRightPaneWnd* pCView = ( CRightPaneWnd* ) GetActiveView();
   if (pCView)
      pCView->m_LBitmapWnd.HandlePalette(WM_PALETTECHANGED, 0, 0);
   
   return CFrameWnd::OnQueryNewPalette();
}

void CMainFrame::OnSysColorChange() 
{
   OnQueryNewPalette();
}