// BrowseDlg.cpp : implementation file
//

#include "stdafx.h"
#include "jpeg2000.h"
#include "BrowseDlg.h"
#include "MainFrm.h"
#include "TCHAR.h"

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

extern CJPEG2000App theApp;

L_INT L_FAR L_EXPORT BrowseDirCB(pBITMAPHANDLE pBitmap, L_TCHAR L_FAR *pszFile, pFILEINFO pInfo, L_INT nStatusCode, L_INT nPercent, L_VOID L_FAR *pUserData);

/////////////////////////////////////////////////////////////////////////////
// CBrowseDlg dialog


CBrowseDlg::CBrowseDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CBrowseDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CBrowseDlg)
	//}}AFX_DATA_INIT
   m_hImgListCtl=NULL;
}


void CBrowseDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CBrowseDlg)
	DDX_Control(pDX, IDC_FILENAME, m_editFileName);
	DDX_Control(pDX, IDC_STATUS, m_staticStatus);
	DDX_Control(pDX, IDC_COMPRESSION, m_editCompression);
	DDX_Control(pDX, IDC_BPP, m_editBPP);
	DDX_Control(pDX, IDC_WIDTH, m_editWidth);
	DDX_Control(pDX, IDC_HEIGHT, m_editHeight);
	DDX_Control(pDX, IDC_RATIO, m_editRatio);
	DDX_Control(pDX, IDC_MEMSIZE, m_editMemSize);
	DDX_Control(pDX, IDC_FILESIZE, m_editFileSize);
	DDX_Control(pDX, IDC_FORMAT, m_editFormat);
	DDX_Control(pDX, IDC_FILELIST, m_listFiles);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CBrowseDlg, CDialog)
	//{{AFX_MSG_MAP(CBrowseDlg)
	ON_WM_DESTROY()
	ON_WM_CLOSE()
   ON_MESSAGE(WM_BROWSE,OnBrowse)
   ON_MESSAGE(WM_INSERTNEWIMAGE,OnInsertNewImage)
	ON_WM_KEYDOWN()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CBrowseDlg message handlers
typedef struct _MYFILTER
{
   TCHAR buf[20];
} MYFILTER;

MYFILTER aMyFilters[]=
{
   TEXT("*.jpg\0"),
   TEXT("*.jpeg\0"),
   TEXT("*.jp2\0"),
   TEXT("*.j2k\0"),
   TEXT("*.cmp\0"),
   TEXT("*.cmw\0"),
};
#define MYFILTERCOUNT sizeof(aMyFilters)/sizeof(MYFILTER)

LRESULT CBrowseDlg::OnInsertNewImage(WPARAM wPara, LPARAM lParam)
{
   L_TCHAR L_FAR *pszFile=NULL;
   L_TCHAR L_FAR *pTemp=NULL;
   LILITEM Item;
   BITMAPHANDLE Bitmap;
   L_INT nRet;
   THUMBOPTIONS to;

   if(!lParam)
      return 0;
   pszFile = (L_TCHAR L_FAR*)lParam;

   pTemp = _tcsrchr(pszFile, '\\');
   pTemp++;

   to.uStructSize = sizeof(THUMBOPTIONS);
   to.nWidth=80;
   to.nHeight=80;
   to.nBits=24,
   to.bLoadStamp=TRUE;
   to.bForceSize=FALSE;
   to.bMaintainAspect=TRUE;
   to.bResample=FALSE;

   nRet = L_CreateThumbnailFromFile(pszFile, &Bitmap, sizeof(BITMAPHANDLE), &to, NULL, NULL, NULL, NULL);
   if(nRet == ERROR_NO_STAMP)
   {
      to.bLoadStamp=FALSE;
      nRet = L_CreateThumbnailFromFile(pszFile, &Bitmap, sizeof(BITMAPHANDLE), &to, NULL, NULL, NULL, NULL);
   }
   if(nRet == SUCCESS)
   {
      Item.uStructSize = sizeof(LILITEM);
      Item.pBitmap   = &Bitmap;
      Item.uBitmapStructSize = sizeof(BITMAPHANDLE);
      Item.pText     = pTemp;
      Item.bSelected = FALSE;
      Item.lData     = 1;
      Item.uMask     = LILITEM_BITMAP  |
                       LILITEM_TEXT    |
                       LILITEM_DATA    |
                       LILITEM_SELECTED;
      m_listFiles.AddString(pszFile);
      nRet = L_ImgListInsert(m_hImgListCtl, &Item);
      L_ImgListEnsureVisible(m_hImgListCtl, L_ImgListGetItemCount(m_hImgListCtl)-1);
      L_FreeBitmap(&Bitmap);
   }
   return nRet;
}

LRESULT CBrowseDlg::OnBrowse(WPARAM wParam, LPARAM lParam)
{
   CString szCaption;
   L_INT nRet;
   int x;
   THUMBOPTIONS to;

   /* start the browse */
   L_ImgListClear(m_hImgListCtl);
   m_listFiles.ResetContent();
   theApp.m_bKillProgress = FALSE;
   theApp.m_bInProcess = TRUE;

   szCaption.Format(TEXT("Browsing: %s"), m_szImageDir);
   SetWindowText(szCaption);

   ::SetFocus(m_hImgListCtl);

   for(x=0;x<MYFILTERCOUNT;x++)
   {
      if(theApp.m_bKillProgress)//must have canceled
      {
         MessageBox(TEXT("Browse Canceled!"), TEXT("Browse"), MB_OK);
         break;
      }
      memset(&to, 0, sizeof(to));
      to.uStructSize = sizeof(to);
      to.nWidth = 80;
      to.nHeight = 80;
      to.nBits = 24;
      to.uCRFlags = 0;
      to.bMaintainAspect = TRUE;
      to.bForceSize = FALSE;
      to.crBackColor = RGB(128,128,128);
      to.bLoadStamp = FALSE;
      to.bResample = FALSE;
      nRet = L_BrowseDir((L_TCHAR L_FAR*)(LPCTSTR)m_szImageDir,
                         aMyFilters[x].buf,
                         &to,
                         FALSE,
                         FALSE,
                         FALSE,
                         0,
                         0,//4000*1024,/* set limit on image size to 4MB*/
                         BrowseDirCB,
                        (L_VOID L_FAR*)this);
      theApp.WriteProfileString(TEXT("Settings"), TEXT("ImageDir"), m_szImageDir);
      switch(nRet)
      {
      case SUCCESS:
         break;
      case ERROR_USER_ABORT:
         MessageBox(TEXT("Browse Canceled!"), TEXT("Browse"), MB_OK);
         theApp.m_bInProcess=FALSE;
         break;
      case ERROR_FILENOTFOUND:
         break;
      default:
         theApp.DisplayLEADError(nRet);
         DestroyWindow();
         break;
      }
      if(nRet==ERROR_USER_ABORT)
         break;
   }
   m_staticStatus.SetWindowText(TEXT("Browse Done - Click for Info, DoubleClick to Load.")); 
   theApp.m_bInProcess=FALSE;
   return 0;
}

BOOL CBrowseDlg::OnInitDialog() 
{
	CDialog::OnInitDialog();
   RECT rcWin;
   LILSELOPTION Opt;
   LILITEMOPTION MOpt;

	CJPEG2000App * pTheApp = (CJPEG2000App *)AfxGetApp();
   SetIcon(pTheApp->LoadIcon(IDR_MAINFRAME), false);

   /* create the LEAD ImageList Control */
   L_UseImageListControl();
   CWnd *pCtl = GetDlgItem(IDC_FRAME_IMGLIST);
   pCtl->GetWindowRect(&rcWin);
   ScreenToClient(&rcWin);
   m_hImgListCtl = L_CreateImageListControl(WS_CHILD|WS_VISIBLE|WS_BORDER,
                                            rcWin.left+10,                 /* x location       */
                                            rcWin.top+20,                 /* y location       */
                                            RECTWIDTH(&rcWin)-20, /* width            */
                                            RECTHEIGHT(&rcWin)-30,/* height           */
                                            this->m_hWnd,              /* parent window    */
                                            IDC_LEADIMAGELIST, /* control ID       */
                                            RGB(128,128,128)); /* background color */

   if(!::IsWindow(m_hImgListCtl))
   {
      MessageBox(TEXT("Error creating control"), TEXT("Error"), MB_OK|MB_ICONERROR);
      DestroyWindow();
      return FALSE;
   }
   // Enable / Disable selection style & method according to the flag at preferences
   L_ImgListGetSelOptions(m_hImgListCtl, &Opt);
   Opt.uStructSize = sizeof(LILSELOPTION);
   Opt.uAllowSelection = ALLOWSELECTION_SINGLE;
   Opt.uSelectionStyle = SELECTIONSTYLE_SELECTCOLOR;
   L_ImgListSetSelOptions(m_hImgListCtl, &Opt);

   // Enable / Disable display text according to the flag at preferences
   memset(&MOpt, 0, sizeof(MOpt));

   L_ImgListGetItemOptions(m_hImgListCtl, &MOpt);
   MOpt.uStructSize = sizeof(LILITEMOPTION);
   MOpt.bDisplayItemText = TRUE;
   L_ImgListSetItemOptions(m_hImgListCtl, &MOpt);

   // Enable / Disable keyboard according to the flag at preferences
   L_ImgListEnableKeyboard(m_hImgListCtl, TRUE);

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

void CBrowseDlg::OnDestroy() 
{
   CMainFrame *pMain = (CMainFrame*)AfxGetMainWnd();
   if(m_hImgListCtl && ::IsWindow(m_hImgListCtl))
      ::DestroyWindow(m_hImgListCtl);
   m_hImgListCtl=NULL;
   pMain->m_bBrowse = FALSE;
   CDialog::OnDestroy();
}

void CBrowseDlg::OnClose() 
{
   CMainFrame *pMain = (CMainFrame*)AfxGetMainWnd();

   if(theApp.m_bInProcess)
   {
      theApp.m_bKillProgress=TRUE;
      return;
   }
   
   if(m_hImgListCtl && ::IsWindow(m_hImgListCtl))
      ::DestroyWindow(m_hImgListCtl);
   m_hImgListCtl=NULL;
   pMain->m_bBrowse = FALSE;
	CDialog::OnClose();
}

void CBrowseDlg::OnImageListMsg(WPARAM wParam, LPARAM lParam)
{
   pLILITEMSEL pItemSel=NULL;
   CString szFileName;
   LOADFILEOPTION lfo;
   FILEINFO fi;
   L_INT nRet;
   pLILCLICK pClick=NULL;
   POINT pt;
   TCHAR drive[_MAX_DRIVE];
   TCHAR dir[_MAX_DIR];
   TCHAR fname[_MAX_FNAME];
   TCHAR ext[_MAX_EXT];

   lfo.uStructSize = sizeof(lfo);

   switch(HIWORD(wParam))
   {
   case L_ILN_DBLCLCK:
      pClick = (pLILCLICK)lParam;
      pt.x=pClick->xPos;
      pt.y=pClick->yPos;
      nRet = L_ImgListHitTest(m_hImgListCtl, &pt);
      if(nRet >= 0)
      {
         m_listFiles.GetText(nRet, szFileName);
         theApp.OpenDocumentFile((LPCTSTR)szFileName);
      }
      break;

   case L_ILN_ITEMSEL:
      if(!theApp.m_bInProcess)
      {
         pItemSel = (pLILITEMSEL)lParam;
         if(pItemSel)
         {
            m_listFiles.GetText(pItemSel->lIndex, szFileName);
            L_GetDefaultLoadFileOption(&lfo, sizeof(LOADFILEOPTION));
            lfo.PageNumber = 1;
            fi.uStructSize = sizeof(FILEINFO);
            nRet = L_FileInfo((L_TCHAR L_FAR*)(LPCTSTR)szFileName, &fi, sizeof(FILEINFO), FILEINFO_TOTALPAGES, &lfo);
            if(nRet!=SUCCESS)
               theApp.DisplayLEADError(nRet);
            else
            {
               CString cs;
               switch(fi.Format)
               {
               case FILE_JFIF:
               case FILE_LEAD1JFIF:
               case FILE_LEAD2JFIF:
                  cs = TEXT("JPEG");
                  break;
               case FILE_JP2:
               case FILE_J2K:
                  cs = TEXT("JPEG 2000");
                  break;
               case FILE_LEAD:
                  cs = TEXT("LEAD CMP");
                  break;
               case FILE_CMW:
                  cs = TEXT("LEAD Wavelet");
                  break;
               default:
                  cs.Format(TEXT("Format: %u"), fi.Format);
                  break;
               }
               m_editFormat.SetWindowText(cs);
               cs.Format(TEXT("%u"), fi.SizeDisk);
               m_editFileSize.SetWindowText(cs);
               cs.Format(TEXT("%u"), fi.SizeMem);
               m_editMemSize.SetWindowText(cs);
               cs.Format(TEXT("%u:1"), (UINT)(fi.SizeMem/fi.SizeDisk));
               m_editRatio.SetWindowText(cs);
               cs.Format(TEXT("%u"), fi.Width);
               m_editWidth.SetWindowText(cs);
               cs.Format(TEXT("%u"), fi.Height);
               m_editHeight.SetWindowText(cs);
               cs.Format(TEXT("%u"), fi.BitsPerPixel);
               m_editBPP.SetWindowText(cs);
               cs=fi.Compression;
               m_editCompression.SetWindowText(cs);
               _tsplitpath(szFileName, drive, dir, fname, ext);
               cs = fname;
               cs += ext;
               m_editFileName.SetWindowText(cs);
            }
         }
      }
      break;
   }
}


BOOL CBrowseDlg::OnCommand(WPARAM wParam, LPARAM lParam) 
{
   CMainFrame *pMain = (CMainFrame*)AfxGetMainWnd();

   if( (HIWORD(wParam) == L_ILN_KEYDOWN) ||
       (HIWORD(wParam) == L_ILN_CLICKED) )
   {
      if(theApp.m_bInProcess)
      {
         theApp.m_bKillProgress = TRUE;
         theApp.m_bInProcess = FALSE;
         return TRUE;
      }
   }

   if(LOWORD(wParam)==IDC_LEADIMAGELIST)
   {
      OnImageListMsg(wParam, lParam);
      return TRUE;
   }
   if(LOWORD(wParam)==IDCANCEL)
   {
      if(theApp.m_bInProcess)
      {
         theApp.m_bKillProgress = TRUE;
         theApp.m_bInProcess = FALSE;
         return TRUE;
      }
      else
         pMain->m_bBrowse = FALSE;
   }
	return CDialog::OnCommand(wParam, lParam);
}

void CBrowseDlg::OnOK() 
{
   CMainFrame *pMain = (CMainFrame*)AfxGetMainWnd();
   if(theApp.m_bInProcess)
   {
      theApp.m_bKillProgress = TRUE;
      theApp.m_bInProcess = FALSE;
      return;
   }
   pMain->m_bBrowse = FALSE;
	CDialog::OnOK();
}

L_INT L_FAR L_EXPORT BrowseDirCB(pBITMAPHANDLE pBitmap, L_TCHAR L_FAR *pszFile, pFILEINFO pInfo, L_INT nStatusCode, L_INT nPercent, L_VOID L_FAR *pUserData)
{
   CBrowseDlg *pDlg=NULL;
   LILITEM Item;
   L_TCHAR L_FAR* pTemp=NULL;
   HWND hCtl;
   MSG msg;
   static BOOL bFirst=TRUE;
   L_TCHAR L_FAR* pszPath=NULL;
   L_TCHAR szLoading[]=TEXT("Loading: ");
   RECT rcWin;

   pDlg = (CBrowseDlg*)pUserData;

   while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
   {
      TranslateMessage (&msg);
      DispatchMessage (&msg);
   }

   if(theApp.m_bKillProgress)
      return (ERROR_USER_ABORT);

   hCtl = pDlg->m_hImgListCtl;

   if(nStatusCode == SUCCESS)/* successful thumbnail generation */
   {
      /* Do something with the thumbnail, i.e. insert into ImageList Control */
      bFirst = TRUE;
      pTemp = _tcsrchr(pszFile, '\\');
      pTemp++;
      Item.uStructSize = sizeof(LILITEM);
      Item.pBitmap   = pBitmap;
      Item.uBitmapStructSize = sizeof(BITMAPHANDLE);
      Item.pText     = pTemp;
      Item.bSelected = FALSE;
      Item.lData     = pInfo->PageNumber;
      Item.uMask     = LILITEM_BITMAP  |
                       LILITEM_TEXT    |
                       LILITEM_DATA    |
                       LILITEM_SELECTED;
      pDlg->m_listFiles.AddString(pszFile);
      L_ImgListInsert(hCtl, &Item);
      L_ImgListEnsureVisible(hCtl, L_ImgListGetItemCount(hCtl)-1);
   }
   else if(nStatusCode == BROWSE_LOADING)/* in the process of loading an image */
   {
      if(bFirst)
      {
         bFirst = FALSE;
         CDC *pDC = pDlg->m_staticStatus.GetDC();
         if(pDC)
         {
            pszPath = (L_TCHAR L_FAR*)GlobalAllocPtr(GMEM_MOVEABLE|GMEM_ZEROINIT, ((lstrlen(pszFile)+lstrlen(szLoading)+4)*sizeof(L_TCHAR)) );
            if(pszPath)
            {
               pDlg->m_staticStatus.GetClientRect(&rcWin);
               lstrcpy(pszPath, szLoading);
               lstrcat(pszPath, pszFile);
               DrawText(pDC->m_hDC, pszPath, lstrlen(pszPath), &rcWin, DT_MODIFYSTRING|DT_SINGLELINE|DT_BOTTOM|DT_PATH_ELLIPSIS);
               pDlg->m_staticStatus.SetWindowText(pszPath); 
               GlobalFreePtr(pszPath);
            }
            pDlg->m_staticStatus.ReleaseDC(pDC);
         }
      }
      return SUCCESS;
   }
   else if(nStatusCode < SUCCESS)
      bFirst = TRUE;

   return SUCCESS;
}

void CBrowseDlg::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
   switch(nChar)
   {
   case VK_ESCAPE:
      theApp.m_bKillProgress = TRUE;
      break;
   }
	CDialog::OnKeyDown(nChar, nRepCnt, nFlags);
}