// 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)
   //}}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()
{
   UNLOCKSUPPORT();
   L_UseImageListControl();

   L_DlgInit (DLG_INIT_COLOR);
   
   m_hCtl          = NULL;
   m_nSelItemIndex = 0;
   m_bShowOverlay  = FALSE;
   m_uCount        = 0;
   m_pElement      = NULL;
   m_hDS           = NULL;

   memset (m_szFileName, 0, sizeof (m_szFileName));
   memset (&Bitmap, 0, sizeof (BITMAPHANDLE));
}

CMainFrame::~CMainFrame()
{
   if (Bitmap.Flags.Allocated)
      L_FreeBitmap (&Bitmap);

   if (m_hDS)
      L_DicomFreeDS (m_hDS);

   L_DlgFree ();
}

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
   }
   m_hDS = L_DicomCreateDS(NULL);
   if(m_hDS == NULL)
   {
      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 API 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;   
   }
   if (Bitmap.Flags.Allocated)
   {
      L_FreeBitmap (&Bitmap);
      memset (&Bitmap, 0, sizeof (BITMAPHANDLE));
      m_nSelItemIndex = 0;
      pRightPane->UpdateView();
   }

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

   strcpy (m_szFileName, (L_CHAR *)(LPCSTR)dlg.GetPathName());
   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 = L_GetOverlayAttributes(&Bitmap, i, &OverlayAttributes, sizeof(OVERLAYATTRIBUTES), uFlags);
      if (!OverlayAttributes.uFlags & OVERLAY_AUTOPAINT )
      {
         OverlayAttributes.uFlags |= OVERLAY_AUTOPAINT;
         L_SetOverlayAttributes(&Bitmap, i, &OverlayAttributes, uFlags);
      }
   }

   pRightPane->UpdateView();
}

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

   m_hLeftPaneWnd = m_wndSplitter.GetPane(0, 0)->m_hWnd;
   m_hRightPaneWnd = m_wndSplitter.GetPane(0, 1)->m_hWnd;
   
   ::GetClientRect(m_hLeftPaneWnd, &rcWin);

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

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

   uFlags = L_GetDisplayMode();
   uFlags |= DISPLAYMODE_RESAMPLE | DISPLAYMODE_SCALETOGRAY;
   L_ImgListSetDisplayFlags(m_hCtl, uFlags);

   // Enable / Disable selection style & method
   L_ImgListGetSelOptions(m_hCtl, &Opt);
   Opt.uStructSize = sizeof(LILSELOPTION);
   Opt.uAllowSelection = ALLOWSELECTION_SINGLE;
   Opt.uSelectionStyle = SELECTIONSTYLE_PRESSEDBUTTON;
   L_ImgListSetSelOptions(m_hCtl, &Opt);

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

   // Enable / Disable keyboard
   L_ImgListEnableKeyboard(m_hCtl, TRUE);

   // Set scroll style Vert / Horz
   L_ImgListSetScrollStyle(m_hCtl, 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;
   LILITEM           Item; 
   L_INT             nRet;
   RGBQUAD           aPalette[2];

   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;

   if (L_DlgColor (m_wndSplitter.GetPane(0,1)->m_hWnd, &ColorDlg) != SUCCESS_DLG_OK)
      return;

   nRet = L_GetOverlayAttributes(&Bitmap, m_nSelItemIndex, &OverlayAttributes, sizeof(OVERLAYATTRIBUTES), OVERLAYATTRIBUTES_COLOR);
   OverlayAttributes.crColor = ColorDlg.crColor;
   nRet = L_SetOverlayAttributes(&Bitmap, m_nSelItemIndex, &OverlayAttributes, OVERLAYATTRIBUTES_COLOR);

   // Update the overlay preview with the new color
   memset (&OverlayBitmap, 0, sizeof (BITMAPHANDLE));
   memset (&Item, 0, sizeof (LILITEM));
   nRet = L_GetOverlayBitmap(&Bitmap, 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);   
   L_PutBitmapColors(&OverlayBitmap,0,2,aPalette);
   // Make the overlay preview looks clearer
   nRet = L_InvertBitmap (&OverlayBitmap);
   nRet = L_SizeBitmap (&OverlayBitmap, 140, 140, SIZE_FAVORBLACK);
   nRet = L_InvertBitmap (&OverlayBitmap);

   Item.uStructSize = sizeof (LILITEM);
   Item.uBitmapStructSize = sizeof (BITMAPHANDLE);
   Item.uMask = LILITEM_BITMAP;
   L_ImgListGetItem (m_hCtl, m_nSelItemIndex, &Item);
   Item.pBitmap = &OverlayBitmap;
   L_ImgListSetItem (m_hCtl, m_nSelItemIndex, &Item);

   m_wndSplitter.GetPane(0, 1)->Invalidate(TRUE);
}

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

void CMainFrame::OnOverlaysSaveOverlay() 
{
   SAVEFILEOPTION SaveFileOptions;
   BITMAPHANDLE   OverlayBitmap ={0};
   L_CHAR         szSaveFileName[_MAX_PATH];
   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()));
   L_GetDefaultSaveFileOption(&SaveFileOptions, sizeof (SAVEFILEOPTION));

   memset(&OverlayBitmap, 0, sizeof (BITMAPHANDLE));
   nRet = L_GetOverlayBitmap(&Bitmap, m_nSelItemIndex, &OverlayBitmap, sizeof (BITMAPHANDLE), OVERLAY_COPY);
   if(nRet == SUCCESS)
   {
      nRet = L_SaveBitmap (szSaveFileName, &OverlayBitmap, FILE_BMP, 1, 2, &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 = L_GetOverlayAttributes(&Bitmap, m_nSelItemIndex, &OverlayAttributes, sizeof(OVERLAYATTRIBUTES), uFlags);
   if (m_bShowOverlay)
      OverlayAttributes.uFlags |= OVERLAY_AUTOPAINT;
   else
      OverlayAttributes.uFlags &= ~OVERLAY_AUTOPAINT;

   L_SetOverlayAttributes(&Bitmap, m_nSelItemIndex, &OverlayAttributes, uFlags);

   pRightPane->UpdateView();
}

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;
   BITMAPHANDLE      NewOverlayBitmap;
   LPSTR             pszFilter = "All files(*.*)|*.*|";
   L_CHAR            szFileName[_MAX_PATH];
   L_CHAR            szItemText[20];
   LILITEM           Item, OldSelectItem;
   L_INT             nRet;

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

   CRightPaneWnd* pRightPane = (CRightPaneWnd*)m_wndSplitter.GetPane(0, 1);
   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 = L_LoadBitmap( szFileName, &NewOverlayBitmap, sizeof(BITMAPHANDLE), 1, ORDER_RGBORGRAY, NULL, NULL);
   if(nRet != SUCCESS)
   {
      MessageBox ("Error loading bitmap.", "Error", MB_OK|MB_ICONERROR);
      return;
   }

   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                = NewOverlayBitmap.Height;
   OverlayAttributes.uColumns             = NewOverlayBitmap.Width;
   OverlayAttributes.uBitsAllocated       = 1;
   OverlayAttributes.nNumFramesInOverlay  = 1;
   OverlayAttributes.uImageFrameOrigin    = 1;
   OverlayAttributes.uFlags |= OVERLAY_AUTOPAINT|OVERLAY_AUTOPROCESS;
   strcpy(OverlayAttributes.szType,"G");

   nRet = L_SetOverlayAttributes(&Bitmap, 
                                 m_uCount, 
                                 &OverlayAttributes, 
                                 OVERLAYATTRIBUTES_FLAGS    | 
                                 OVERLAYATTRIBUTES_ORIGIN   |
                                 OVERLAYATTRIBUTES_DICOM    |
                                 OVERLAYATTRIBUTES_COLOR);
   if(nRet == SUCCESS)
   {
      nRet = L_SetOverlayBitmap( &Bitmap, m_uCount, &NewOverlayBitmap, OVERLAY_COPY);
      if(nRet != SUCCESS)
      {         
         MessageBox ("Error inserting overlay bitmap.", "Error", MB_OK|MB_ICONERROR);
         L_FreeBitmap(&NewOverlayBitmap);
         return;
      }
   }
   else
   {
      MessageBox ("Error setting overlay attributes", "Error", MB_OK|MB_ICONERROR);
      L_FreeBitmap(&NewOverlayBitmap);
      return;
   }

   /* 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;
   L_ImgListGetSelItems(m_hCtl, &OldSelectItem);
   OldSelectItem.bSelected = FALSE;
   nRet = L_ImgListSetItem (m_hCtl, OldSelectItem.lIndex, &OldSelectItem);

   // 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            = &NewOverlayBitmap;
   sprintf (szItemText, "Overlay %d", m_uCount);
   Item.pText              = szItemText;
   Item.bSelected          = TRUE;
   L_ImgListInsert(m_hCtl, &Item);
   L_ImgListEnsureVisible(m_hCtl, L_ImgListGetItemCount(m_hCtl)-1);

   m_uCount++;
   m_nSelItemIndex = m_uCount - 1;
   pRightPane->UpdateView();
}

void CMainFrame::OnUpdateOverlaysInsertOverlay(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable ((m_uCount < (MAX_OVERLAYS+1)) ? 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);
   if (dlg.DoModal () != IDOK) 
   {
      return;   
   }

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

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

   uRet = L_DicomGetInfoImage (m_hDS, m_pElement, &Info, 0);
   uRet = L_DicomSetImage ( m_hDS, 
                            NULL, 
                            &Bitmap, 
                            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 = L_DicomSaveDS(m_hDS, 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);
}