2360 lines
55 KiB
C++
2360 lines
55 KiB
C++
// ==========================================================================
|
|
// Class Implementation : COXPreviewDialog
|
|
// ==========================================================================
|
|
|
|
// Source file : OXPreviewDialog.cpp
|
|
|
|
// Version: 9.3
|
|
|
|
// This software along with its related components, documentation and files ("The Libraries")
|
|
// is © 1994-2007 The Code Project (1612916 Ontario Limited) and use of The Libraries is
|
|
// governed by a software license agreement ("Agreement"). Copies of the Agreement are
|
|
// available at The Code Project (www.codeproject.com), as part of the package you downloaded
|
|
// to obtain this file, or directly from our office. For a copy of the license governing
|
|
// this software, you may contact us at legalaffairs@codeproject.com, or by calling 416-849-8900.
|
|
|
|
// //////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h" // standard MFC include
|
|
#include <dlgs.h>
|
|
#include "OXPreviewDialog.h" // class specification
|
|
#include "OXMainRes.h"
|
|
|
|
#include "WTypes.h"
|
|
|
|
#ifndef __OXMFCIMPL_H__
|
|
#if _MFC_VER >= 0x0700
|
|
#if _MFC_VER >= 1400
|
|
#include <afxtempl.h>
|
|
#endif
|
|
#include <..\src\mfc\afximpl.h>
|
|
#else
|
|
#include <..\src\afximpl.h>
|
|
#endif
|
|
#define __OXMFCIMPL_H__
|
|
#endif
|
|
|
|
#ifndef MORE_THAN_ONE
|
|
#define MORE_THAN_ONE 0xffff
|
|
#endif
|
|
|
|
#ifndef OX_MIN_PREVIEWWND_WIDTH
|
|
#define OX_MIN_PREVIEWWND_WIDTH 50
|
|
#endif
|
|
|
|
#ifndef OX_MIN_SHELLITEMSLISTCTRL_WIDTH
|
|
#define OX_MIN_SHELLITEMSLISTCTRL_WIDTH 50
|
|
#endif
|
|
|
|
#ifndef OX_IDC_SET_PREVIEW
|
|
#define OX_IDC_SET_PREVIEW 0xa100
|
|
#endif
|
|
|
|
#ifndef WM_OX_LOAD_PREVIEWWND_OFFSET
|
|
#define WM_OX_LOAD_PREVIEWWND_OFFSET WM_APP+20
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char BASED_CODE THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(COXPreviewWnd, CWnd)
|
|
ON_WM_PAINT()
|
|
ON_WM_ERASEBKGND()
|
|
END_MESSAGE_MAP()
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
void COXPreviewWnd::OnPaint()
|
|
{
|
|
CPaintDC dc(this);
|
|
|
|
CRect rect;
|
|
GetClientRect(rect);
|
|
ASSERT(m_pPreviewDlg!=NULL);
|
|
m_pPreviewDlg->OnPaintPreview(&dc,rect);
|
|
}
|
|
|
|
|
|
BOOL COXPreviewWnd::OnEraseBkgnd(CDC* pDC)
|
|
{
|
|
UNREFERENCED_PARAMETER(pDC);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL COXPreviewWnd::Create(CWnd* pParent, CRect rect, UINT nID)
|
|
{
|
|
return CWnd::CreateEx(WS_EX_STATICEDGE,
|
|
AfxRegisterWndClass(CS_DBLCLKS,::LoadCursor(NULL,IDC_ARROW),
|
|
(HBRUSH)(COLOR_BTNFACE+1),0),_T(""),WS_CHILD|WS_VISIBLE,rect,pParent,nID);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef OX_PREVIEW_GRAPHICS
|
|
BOOL COXGraphicsFileViewer::OnNewFileSelect(const CString& sFilename,
|
|
BOOL bViewerFound/*=FALSE*/)
|
|
{
|
|
COXFilePath pathPreview(sFilename);
|
|
|
|
BOOL bSuccess=FALSE;
|
|
if(!bViewerFound && !sFilename.IsEmpty() && pathPreview.Exists())
|
|
{
|
|
CWaitCursor wait;
|
|
|
|
#ifdef OX_PREVIEW_ICON
|
|
if(!bSuccess && ::IsWindow(m_imageListBox.GetSafeHwnd()))
|
|
{
|
|
m_imageListBox.EmptyImageList();
|
|
CString sExtension=pathPreview.GetExtender();
|
|
if(sExtension.CompareNoCase(_T("ico"))==0 ||
|
|
sExtension.CompareNoCase(_T("cur"))==0 ||
|
|
sExtension.CompareNoCase(_T("ani"))==0 ||
|
|
sExtension.CompareNoCase(_T("icl"))==0)
|
|
{
|
|
if(m_imageListBox.LoadIconsFromFile(sFilename,FALSE))
|
|
{
|
|
bSuccess=(m_imageListBox.GetCount()>0);
|
|
if(bSuccess)
|
|
{
|
|
m_imageListBox.ShowWindow(SW_SHOWNA);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(!bSuccess && ::IsWindow(m_imageListBox.GetSafeHwnd()))
|
|
{
|
|
m_imageListBox.ShowWindow(SW_HIDE);
|
|
}
|
|
#endif
|
|
|
|
#ifdef OX_PREVIEW_BMP
|
|
if(!bSuccess)
|
|
{
|
|
#ifdef OXDIB_SUPPORTJPEG
|
|
bSuccess=m_dib.ReadJPEG(pathPreview.GetPath());
|
|
#endif // OXDIB_SUPPORTJPEG
|
|
if(!bSuccess)
|
|
{
|
|
bSuccess=m_dib.Read(pathPreview.GetPath());
|
|
}
|
|
#endif
|
|
#ifdef OX_PREVIEW_METAFILE
|
|
if(!bSuccess)
|
|
{
|
|
bSuccess=(m_MetaFile.LoadFile(pathPreview.GetPath())!=NULL);
|
|
}
|
|
else
|
|
{
|
|
m_MetaFile.CloseFile();
|
|
}
|
|
#endif
|
|
}
|
|
#ifdef OX_PREVIEW_BMP
|
|
else
|
|
{
|
|
m_dib.Empty();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if(!bSuccess)
|
|
{
|
|
#ifdef OX_PREVIEW_BMP
|
|
m_dib.Empty();
|
|
#endif
|
|
#ifdef OX_PREVIEW_METAFILE
|
|
m_MetaFile.CloseFile();
|
|
#endif
|
|
#ifdef OX_PREVIEW_ICON
|
|
if(::IsWindow(m_imageListBox.GetSafeHwnd()))
|
|
{
|
|
m_imageListBox.EmptyImageList();
|
|
m_imageListBox.ShowWindow(SW_HIDE);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
m_bCanPreview=bSuccess;
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
BOOL COXGraphicsFileViewer::OnPaintPreview(CDC* pDC, const CRect& paintRect)
|
|
{
|
|
if(!CanPreview())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bSuccess=FALSE;
|
|
|
|
#ifdef OX_PREVIEW_ICON
|
|
if(::IsWindow(m_imageListBox.GetSafeHwnd()) && m_imageListBox.GetCount()>0)
|
|
{
|
|
bSuccess=TRUE;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OX_PREVIEW_BMP
|
|
if(!bSuccess && !m_dib.IsEmpty())
|
|
{
|
|
CRect dibRect;
|
|
CSize dibSize;
|
|
dibSize = m_dib.GetSize();
|
|
dibRect.SetRect(0,0, dibSize.cx, dibSize.cy);
|
|
|
|
CPalette* pPalette = m_dib.GetPalette();
|
|
if (pPalette != NULL)
|
|
{
|
|
CPalette* pOldPalette = pDC->SelectPalette(pPalette,FALSE);
|
|
pDC->RealizePalette();
|
|
pDC->SelectPalette(pOldPalette, FALSE);
|
|
}
|
|
|
|
CRect rect=COXPreviewDialog::AdjustRectToFit(dibRect,paintRect);
|
|
m_dib.Paint(pDC,rect,dibRect);
|
|
pDC->ExcludeClipRect(rect);
|
|
|
|
// fill the background
|
|
pDC->FillSolidRect(paintRect,::GetSysColor(COLOR_BTNFACE));
|
|
|
|
bSuccess=TRUE;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OX_PREVIEW_METAFILE
|
|
if(!bSuccess)
|
|
{
|
|
if(m_MetaFile.GethEMF()!=NULL)
|
|
{
|
|
// fill the background
|
|
pDC->FillSolidRect(paintRect,::GetSysColor(COLOR_BTNFACE));
|
|
// paint the metafile
|
|
CRect rect=paintRect;
|
|
if(m_MetaFile.PlayFile(pDC,&rect))
|
|
{
|
|
pDC->ExcludeClipRect(rect);
|
|
bSuccess=TRUE;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
BOOL COXGraphicsFileViewer::OnDoRealizePalette(CWnd* pFocusWnd)
|
|
{
|
|
#ifndef OX_PREVIEW_BMP
|
|
UNREFERENCED_PARAMETER(pFocusWnd);
|
|
#endif
|
|
|
|
if(!CanPreview())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
#ifdef OX_PREVIEW_ICON
|
|
if(::IsWindow(m_imageListBox.GetSafeHwnd()) && m_imageListBox.GetCount()>0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OX_PREVIEW_BMP
|
|
if(m_dib.IsEmpty())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
UINT nColorsChanged = 0;
|
|
|
|
CPalette* pPalette = m_dib.GetPalette();
|
|
if (pPalette != NULL)
|
|
{
|
|
CClientDC appDC(m_pPreviewDialog->GetPreviewWnd());
|
|
|
|
// bForceBackground flag is FALSE only if pFocusWnd != this (this dialog)
|
|
CPalette* oldPalette=appDC.SelectPalette(pPalette,
|
|
pFocusWnd!=m_pPreviewDialog->GetPreviewWnd());
|
|
if(oldPalette!=NULL)
|
|
{
|
|
nColorsChanged=appDC.RealizePalette();
|
|
appDC.SelectPalette(oldPalette,TRUE);
|
|
}
|
|
else
|
|
{
|
|
TRACE(_T("SelectPalette failed in COXGraphicsPreviewDlg::OnDoRealizePalette\n"));
|
|
}
|
|
}
|
|
|
|
if(nColorsChanged != 0)
|
|
{
|
|
m_pPreviewDialog->GetPreviewWnd()->Invalidate(FALSE);
|
|
}
|
|
return TRUE;
|
|
#else
|
|
return FALSE;
|
|
#endif
|
|
}
|
|
|
|
|
|
void COXGraphicsFileViewer::OnChangeSize()
|
|
{
|
|
#ifdef OX_PREVIEW_ICON
|
|
ASSERT(m_pPreviewDialog!=NULL);
|
|
ASSERT(m_pPreviewDialog->GetPreviewWnd()!=NULL);
|
|
|
|
if(!::IsWindow(m_imageListBox.GetSafeHwnd()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
CRect rect;
|
|
m_pPreviewDialog->GetPreviewWnd()->GetClientRect(rect);
|
|
CSize szWindow(rect.Width(),rect.Height());
|
|
|
|
m_imageListBox.MoveWindow(0,0,szWindow.cx,szWindow.cy);
|
|
#endif
|
|
}
|
|
|
|
void COXGraphicsFileViewer::OnPreview(BOOL bPreview)
|
|
{
|
|
#ifdef OX_PREVIEW_ICON
|
|
if(CanPreview())
|
|
{
|
|
ASSERT(::IsWindow(m_imageListBox.GetSafeHwnd()));
|
|
if(m_imageListBox.GetCount()>0)
|
|
{
|
|
m_imageListBox.ShowWindow((bPreview ? SW_SHOWNA : SW_HIDE));
|
|
}
|
|
}
|
|
#else
|
|
UNREFERENCED_PARAMETER(bPreview);
|
|
#endif
|
|
}
|
|
|
|
void COXGraphicsFileViewer::OnCreatePreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
#ifdef OX_PREVIEW_ICON
|
|
ASSERT(pPreviewWnd!=NULL);
|
|
ASSERT(::IsWindow(pPreviewWnd->GetSafeHwnd()));
|
|
CRect rect;
|
|
pPreviewWnd->GetClientRect(rect);
|
|
|
|
ASSERT(!::IsWindow(m_imageListBox.GetSafeHwnd()));
|
|
VERIFY(m_imageListBox.CreateEx(0,_T("ListBox"),_T(""),
|
|
WS_CHILD|WS_VSCROLL|WS_HSCROLL|LBS_NOTIFY|LBS_OWNERDRAWFIXED|
|
|
LBS_NOINTEGRALHEIGHT|LBS_MULTICOLUMN,rect,pPreviewWnd,AFX_IDW_PANE_FIRST));
|
|
m_imageListBox.SetHighlightColor(m_imageListBox.GetBkColor());
|
|
#else
|
|
UNREFERENCED_PARAMETER(pPreviewWnd);
|
|
#endif
|
|
}
|
|
|
|
void COXGraphicsFileViewer::OnDestroyPreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pPreviewWnd);
|
|
|
|
#ifdef OX_PREVIEW_ICON
|
|
ASSERT(::IsWindow(m_imageListBox.GetSafeHwnd()));
|
|
m_imageListBox.DestroyWindow();
|
|
|
|
m_bCanPreview=FALSE;
|
|
#endif
|
|
}
|
|
#endif // OX_PREVIEW_GRAPHICS
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef OX_PREVIEW_PLAINTEXT
|
|
#ifdef _UNICODE
|
|
BOOL COXTextFileViewer::OnNewFileSelect(const CString& /*sFilename*/,
|
|
BOOL /*bViewerFound*/)
|
|
{
|
|
return FALSE;
|
|
#else
|
|
BOOL COXTextFileViewer::OnNewFileSelect(const CString& sFilename,
|
|
BOOL bViewerFound)
|
|
{
|
|
BOOL bViewerCtrlCreated=TRUE;
|
|
if(!::IsWindow(m_edit.GetSafeHwnd()))
|
|
{
|
|
bViewerCtrlCreated=FALSE;
|
|
}
|
|
|
|
COXFilePath pathPreview(sFilename);
|
|
|
|
BOOL bSuccess=FALSE;
|
|
if(bViewerCtrlCreated && !bViewerFound && !sFilename.IsEmpty() &&
|
|
pathPreview.Exists())
|
|
{
|
|
CWaitCursor wait;
|
|
|
|
CFile file;
|
|
if(file.Open(sFilename,CFile::modeRead) &&
|
|
file.m_hFile != CFile::hFileNull)
|
|
{
|
|
file.SeekToBegin();
|
|
int nSize=(int)file.SeekToEnd();
|
|
file.SeekToBegin();
|
|
// max size of the displayed file is 64Kb
|
|
if(nSize<0x0000ffff)
|
|
{
|
|
CString sText;
|
|
VERIFY(file.Read((void*)sText.GetBuffer(nSize),nSize)==(UINT)nSize);
|
|
m_edit.SetWindowText(sText);
|
|
bSuccess=TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!bSuccess && bViewerCtrlCreated)
|
|
{
|
|
m_edit.ShowWindow(SW_HIDE);
|
|
}
|
|
else if(bSuccess && bViewerCtrlCreated)
|
|
{
|
|
m_edit.ShowWindow(SW_SHOWNA);
|
|
}
|
|
|
|
m_bCanPreview=bSuccess;
|
|
|
|
return bSuccess;
|
|
#endif
|
|
}
|
|
|
|
|
|
BOOL COXTextFileViewer::OnPaintPreview(CDC* pDC, const CRect& paintRect)
|
|
{
|
|
UNREFERENCED_PARAMETER(pDC);
|
|
UNREFERENCED_PARAMETER(paintRect);
|
|
|
|
return (CanPreview());
|
|
}
|
|
|
|
|
|
BOOL COXTextFileViewer::OnDoRealizePalette(CWnd* pFocusWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pFocusWnd);
|
|
|
|
return (CanPreview());
|
|
}
|
|
|
|
|
|
void COXTextFileViewer::OnChangeSize()
|
|
{
|
|
ASSERT(m_pPreviewDialog!=NULL);
|
|
ASSERT(m_pPreviewDialog->GetPreviewWnd()!=NULL);
|
|
|
|
if(!::IsWindow(m_edit.GetSafeHwnd()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
CRect rect;
|
|
m_pPreviewDialog->GetPreviewWnd()->GetClientRect(rect);
|
|
CSize szWindow(rect.Width(),rect.Height());
|
|
|
|
m_edit.MoveWindow(0,0,szWindow.cx,szWindow.cy);
|
|
}
|
|
|
|
void COXTextFileViewer::OnPreview(BOOL bPreview)
|
|
{
|
|
if(CanPreview())
|
|
{
|
|
ASSERT(::IsWindow(m_edit.GetSafeHwnd()));
|
|
m_edit.ShowWindow((bPreview ? SW_SHOWNA : SW_HIDE));
|
|
}
|
|
}
|
|
|
|
void COXTextFileViewer::OnCreatePreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
ASSERT(pPreviewWnd!=NULL);
|
|
ASSERT(::IsWindow(pPreviewWnd->GetSafeHwnd()));
|
|
CRect rect;
|
|
pPreviewWnd->GetClientRect(rect);
|
|
|
|
ASSERT(!::IsWindow(m_edit.GetSafeHwnd()));
|
|
VERIFY(m_edit.CreateEx(0,_T("Edit"),_T(""),
|
|
WS_CHILD|WS_VSCROLL|ES_MULTILINE|ES_AUTOVSCROLL|ES_READONLY,
|
|
rect,pPreviewWnd,AFX_IDW_PANE_FIRST));
|
|
// change the font to default GUI one
|
|
CFont* pFont=CFont::FromHandle((HFONT)::GetStockObject(DEFAULT_GUI_FONT));
|
|
m_edit.SetFont(pFont);
|
|
}
|
|
|
|
void COXTextFileViewer::OnDestroyPreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pPreviewWnd);
|
|
|
|
ASSERT(::IsWindow(m_edit.GetSafeHwnd()));
|
|
m_edit.DestroyWindow();
|
|
|
|
m_bCanPreview=FALSE;
|
|
}
|
|
#endif // OX_PREVIEW_PLAINTEXT
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef OX_PREVIEW_RTF
|
|
#ifdef _UNICODE
|
|
BOOL COXRTFFileViewer::OnNewFileSelect(const CString& /*sFilename*/,
|
|
BOOL /*bViewerFound*/)
|
|
{
|
|
return FALSE;
|
|
#else
|
|
BOOL COXRTFFileViewer::OnNewFileSelect(const CString& sFilename,
|
|
BOOL bViewerFound)
|
|
{
|
|
BOOL bViewerCtrlCreated=TRUE;
|
|
if(!::IsWindow(m_richEdit.GetSafeHwnd()))
|
|
{
|
|
bViewerCtrlCreated=FALSE;
|
|
}
|
|
|
|
COXFilePath pathPreview(sFilename);
|
|
|
|
BOOL bSuccess=FALSE;
|
|
if(bViewerCtrlCreated && !bViewerFound && !sFilename.IsEmpty() &&
|
|
pathPreview.Exists())
|
|
{
|
|
CWaitCursor wait;
|
|
|
|
bSuccess=FALSE;
|
|
if(m_file.m_hFile != CFile::hFileNull)
|
|
{
|
|
m_file.Close();
|
|
}
|
|
m_file.Open(sFilename,CFile::modeRead);
|
|
if(m_file.m_hFile != CFile::hFileNull)
|
|
{
|
|
if(IsRTF(&m_file))
|
|
{
|
|
LoadRTF();
|
|
bSuccess=TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!bSuccess && bViewerCtrlCreated)
|
|
{
|
|
m_richEdit.ShowWindow(SW_HIDE);
|
|
if(m_file.m_hFile != CFile::hFileNull)
|
|
{
|
|
m_file.Close();
|
|
}
|
|
}
|
|
else if(bSuccess && bViewerCtrlCreated)
|
|
{
|
|
m_richEdit.ShowWindow(SW_SHOWNA);
|
|
}
|
|
|
|
m_bCanPreview=bSuccess;
|
|
|
|
return bSuccess;
|
|
#endif
|
|
}
|
|
|
|
|
|
BOOL COXRTFFileViewer::OnPaintPreview(CDC* pDC, const CRect& paintRect)
|
|
{
|
|
UNREFERENCED_PARAMETER(pDC);
|
|
UNREFERENCED_PARAMETER(paintRect);
|
|
|
|
return (CanPreview());
|
|
}
|
|
|
|
|
|
BOOL COXRTFFileViewer::OnDoRealizePalette(CWnd* pFocusWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pFocusWnd);
|
|
|
|
return (CanPreview());
|
|
}
|
|
|
|
|
|
void COXRTFFileViewer::OnChangeSize()
|
|
{
|
|
ASSERT(m_pPreviewDialog!=NULL);
|
|
ASSERT(m_pPreviewDialog->GetPreviewWnd()!=NULL);
|
|
|
|
if(!::IsWindow(m_richEdit.GetSafeHwnd()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
CRect rect;
|
|
m_pPreviewDialog->GetPreviewWnd()->GetClientRect(rect);
|
|
CSize szWindow(rect.Width(),rect.Height());
|
|
|
|
m_richEdit.MoveWindow(0,0,szWindow.cx,szWindow.cy);
|
|
}
|
|
|
|
void COXRTFFileViewer::OnPreview(BOOL bPreview)
|
|
{
|
|
if(CanPreview())
|
|
{
|
|
ASSERT(::IsWindow(m_richEdit.GetSafeHwnd()));
|
|
m_richEdit.ShowWindow((bPreview ? SW_SHOWNA : SW_HIDE));
|
|
}
|
|
}
|
|
|
|
void COXRTFFileViewer::OnCreatePreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
ASSERT(pPreviewWnd!=NULL);
|
|
ASSERT(::IsWindow(pPreviewWnd->GetSafeHwnd()));
|
|
CRect rect;
|
|
pPreviewWnd->GetClientRect(rect);
|
|
|
|
ASSERT(!::IsWindow(m_richEdit.GetSafeHwnd()));
|
|
|
|
#if _MFC_VER >= 0x0700
|
|
VERIFY(m_richEdit.Create(WS_CHILD|WS_VSCROLL|ES_MULTILINE|ES_AUTOVSCROLL|ES_READONLY,
|
|
rect,pPreviewWnd,AFX_IDW_PANE_FIRST));
|
|
#else
|
|
VERIFY(m_richEdit.CreateEx(0,_T("RICHEDIT"),_T(""),
|
|
WS_CHILD|WS_VSCROLL|ES_MULTILINE|ES_AUTOVSCROLL|ES_READONLY,
|
|
rect,pPreviewWnd,AFX_IDW_PANE_FIRST));
|
|
#endif
|
|
}
|
|
|
|
void COXRTFFileViewer::OnDestroyPreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pPreviewWnd);
|
|
|
|
ASSERT(::IsWindow(m_richEdit.GetSafeHwnd()));
|
|
m_richEdit.DestroyWindow();
|
|
|
|
m_bCanPreview=FALSE;
|
|
}
|
|
|
|
|
|
void COXRTFFileViewer::LoadRTF()
|
|
{
|
|
ASSERT(::IsWindow(m_richEdit.GetSafeHwnd()));
|
|
ASSERT(m_file.m_hFile != CFile::hFileNull);
|
|
ASSERT(IsRTF(&m_file));
|
|
|
|
m_file.SeekToBegin();
|
|
|
|
EDITSTREAM es;
|
|
es.dwCookie=(DWORD_PTR)this;
|
|
es.dwError=0;
|
|
es.pfnCallback=(EDITSTREAMCALLBACK)RichEditStreamInCallback;
|
|
m_richEdit.StreamIn(SF_RTF,es);
|
|
}
|
|
|
|
BOOL COXRTFFileViewer::IsRTF(CFile* pFile)
|
|
{
|
|
ASSERT(pFile!=NULL);
|
|
ASSERT(pFile->m_hFile != CFile::hFileNull);
|
|
|
|
int nPos=(int)pFile->Seek(0,CFile::current);
|
|
|
|
// check if specified file is of RTF format
|
|
pFile->SeekToBegin();
|
|
int nSignatureLength=5;
|
|
char* pBuffer=new char[nSignatureLength+1];
|
|
BOOL bRTFFile=
|
|
(pFile->Read((void*)pBuffer,nSignatureLength)==(UINT)nSignatureLength);
|
|
pBuffer[nSignatureLength]='\0';
|
|
if(bRTFFile)
|
|
{
|
|
CString sSignature;
|
|
#ifdef _UNICODE
|
|
_mbstowcsz((LPTSTR)sSignature.GetBuffer(nSignatureLength),
|
|
(LPSTR)pBuffer,nSignatureLength);
|
|
sSignature.ReleaseBuffer();
|
|
#else
|
|
sSignature=pBuffer;
|
|
#endif
|
|
bRTFFile=(sSignature.CompareNoCase(_T("{\\rtf"))==0);
|
|
}
|
|
delete[] pBuffer;
|
|
|
|
pFile->Seek(nPos,CFile::begin);
|
|
|
|
return bRTFFile;
|
|
}
|
|
|
|
|
|
DWORD CALLBACK COXRTFFileViewer::RichEditStreamInCallback(DWORD_PTR dwCookie,
|
|
LPBYTE pbBuff,
|
|
LONG cb,
|
|
LONG FAR *pcb)
|
|
{
|
|
#if defined (_WINDLL)
|
|
#if defined (_AFXDLL)
|
|
AFX_MANAGE_STATE(AfxGetAppModuleState());
|
|
#else
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
#endif
|
|
#endif
|
|
|
|
COXRTFFileViewer* pViewer=(COXRTFFileViewer*)dwCookie;
|
|
ASSERT(pViewer!=NULL);
|
|
|
|
int nPos=(int)pViewer->m_file.Seek(0,CFile::current);
|
|
int nSize=(int)pViewer->m_file.SeekToEnd();
|
|
pViewer->m_file.Seek(nPos,CFile::begin);
|
|
if(nPos>=nSize)
|
|
{
|
|
*pcb=0;
|
|
return (DWORD)E_FAIL;
|
|
}
|
|
|
|
if(nSize>cb)
|
|
{
|
|
nSize=cb-cb%sizeof(TCHAR);
|
|
}
|
|
TCHAR* pBuffer=new TCHAR[nSize/sizeof(TCHAR)];
|
|
VERIFY(pViewer->m_file.Read((void*)pBuffer,nSize)==(UINT)nSize);
|
|
|
|
#ifdef _UNICODE
|
|
_wcstombsz((LPSTR)pbBuff,(LPCTSTR)pBuffer,nSize);
|
|
#else
|
|
::memcpy((void*)pbBuff,(const void*)pBuffer,nSize);
|
|
#endif
|
|
|
|
delete[] pBuffer;
|
|
|
|
*pcb=nSize;
|
|
|
|
return NOERROR;
|
|
}
|
|
#endif // OX_PREVIEW_RTF
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef OX_PREVIEW_HTML
|
|
BOOL COXHTMLFileViewer::OnNewFileSelect(const CString& sFilename,
|
|
BOOL bViewerFound/*=FALSE*/)
|
|
{
|
|
BOOL bViewerCtrlCreated=TRUE;
|
|
if(!::IsWindow(m_HTMLBrowserWnd.GetSafeHwnd()))
|
|
{
|
|
bViewerCtrlCreated=FALSE;
|
|
}
|
|
|
|
COXFilePath pathPreview(sFilename);
|
|
|
|
BOOL bSuccess=FALSE;
|
|
if(bViewerCtrlCreated && !bViewerFound && !sFilename.IsEmpty() &&
|
|
pathPreview.Exists())
|
|
{
|
|
CWaitCursor wait;
|
|
|
|
CString sExtension=pathPreview.GetExtender();
|
|
// search registry for information on the content type
|
|
if(sExtension.IsEmpty())
|
|
{
|
|
sExtension=_T("*");
|
|
}
|
|
else
|
|
{
|
|
sExtension=_T(".")+sExtension;
|
|
}
|
|
HKEY hExtensionContentTypeKey=NULL;
|
|
if(::RegOpenKeyEx(HKEY_CLASSES_ROOT,sExtension,0,
|
|
KEY_QUERY_VALUE,&hExtensionContentTypeKey)==ERROR_SUCCESS)
|
|
{
|
|
ASSERT(hExtensionContentTypeKey!=NULL);
|
|
|
|
DWORD dwType=REG_SZ;
|
|
CString sContentType;
|
|
DWORD dwContentTypeStringLength=MAX_PATH;
|
|
if(::RegQueryValueEx(hExtensionContentTypeKey,_T("Content Type"),NULL,
|
|
&dwType,(LPBYTE)sContentType.GetBuffer(dwContentTypeStringLength),
|
|
&dwContentTypeStringLength)==ERROR_SUCCESS)
|
|
{
|
|
HKEY hContentTypeKey=NULL;
|
|
CString sSubkey;
|
|
sSubkey.Format(_T("MIME\\Database\\Content Type\\%s"),sContentType);
|
|
if(::RegOpenKeyEx(HKEY_CLASSES_ROOT,sSubkey,0,
|
|
KEY_QUERY_VALUE,&hContentTypeKey)==ERROR_SUCCESS)
|
|
{
|
|
ASSERT(hContentTypeKey!=NULL);
|
|
|
|
CString sCLSID;
|
|
dwContentTypeStringLength=MAX_PATH;
|
|
if(sExtension.CompareNoCase(_T(".doc"))==0 ||
|
|
sExtension.CompareNoCase(_T(".rtf"))==0 ||
|
|
sExtension.CompareNoCase(_T(".dot"))==0 ||
|
|
sExtension.CompareNoCase(_T(".xls"))==0 ||
|
|
::RegQueryValueEx(hContentTypeKey,_T("CLSID"),NULL,
|
|
&dwType,(LPBYTE)sCLSID.GetBuffer(dwContentTypeStringLength),
|
|
&dwContentTypeStringLength)==ERROR_SUCCESS)
|
|
{
|
|
ASSERT(m_pIWebBrowser!=NULL);
|
|
|
|
COleVariant vURL(sFilename,VT_BSTR);
|
|
COleVariant vFlags((long)(navNoHistory), VT_I4);
|
|
COleVariant vHeaders((LPCTSTR)NULL,VT_BSTR);
|
|
COleVariant vTargetFrameName((LPCTSTR)NULL,VT_BSTR);
|
|
COleSafeArray vPostData;
|
|
HRESULT hResult=m_pIWebBrowser->
|
|
Navigate2(vURL,vFlags,vTargetFrameName,vPostData,vHeaders);
|
|
|
|
bSuccess=(hResult==S_OK);
|
|
|
|
::RegCloseKey(hContentTypeKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
::RegCloseKey(hExtensionContentTypeKey);
|
|
}
|
|
}
|
|
|
|
m_bCanPreview=bSuccess;
|
|
|
|
if(!bSuccess && bViewerCtrlCreated)
|
|
{
|
|
m_HTMLBrowserWnd.MoveWindow(0,0,0,0);
|
|
}
|
|
else if(bSuccess && bViewerCtrlCreated)
|
|
{
|
|
OnChangeSize();
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
BOOL COXHTMLFileViewer::OnPaintPreview(CDC* pDC, const CRect& paintRect)
|
|
{
|
|
UNREFERENCED_PARAMETER(pDC);
|
|
UNREFERENCED_PARAMETER(paintRect);
|
|
|
|
return (CanPreview());
|
|
}
|
|
|
|
|
|
BOOL COXHTMLFileViewer::OnDoRealizePalette(CWnd* pFocusWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pFocusWnd);
|
|
|
|
return (CanPreview());
|
|
}
|
|
|
|
|
|
void COXHTMLFileViewer::OnChangeSize()
|
|
{
|
|
ASSERT(m_pPreviewDialog!=NULL);
|
|
ASSERT(m_pPreviewDialog->GetPreviewWnd()!=NULL);
|
|
|
|
if(!::IsWindow(m_HTMLBrowserWnd.GetSafeHwnd()) || !CanPreview())
|
|
{
|
|
return;
|
|
}
|
|
|
|
CRect rect;
|
|
m_pPreviewDialog->GetPreviewWnd()->GetClientRect(rect);
|
|
CSize szWindow(rect.Width(),rect.Height());
|
|
|
|
m_HTMLBrowserWnd.MoveWindow(0,0,szWindow.cx,szWindow.cy);
|
|
}
|
|
|
|
void COXHTMLFileViewer::OnPreview(BOOL bPreview)
|
|
{
|
|
if(CanPreview())
|
|
{
|
|
ASSERT(::IsWindow(m_HTMLBrowserWnd.GetSafeHwnd()));
|
|
if(bPreview)
|
|
{
|
|
OnChangeSize();
|
|
}
|
|
else
|
|
{
|
|
m_HTMLBrowserWnd.MoveWindow(0,0,0,0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void COXHTMLFileViewer::OnCreatePreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
ASSERT(pPreviewWnd!=NULL);
|
|
ASSERT(::IsWindow(pPreviewWnd->GetSafeHwnd()));
|
|
|
|
ASSERT(!::IsWindow(m_HTMLBrowserWnd.GetSafeHwnd()) && m_pIWebBrowser==NULL);
|
|
if(m_HTMLBrowserWnd.CreateControl(CLSID_WebBrowser,_T(""),
|
|
WS_CHILD|WS_VISIBLE,CRect(0,0,0,0),pPreviewWnd,AFX_IDW_PANE_FIRST))
|
|
{
|
|
LPUNKNOWN lpIUnknown=m_HTMLBrowserWnd.GetControlUnknown();
|
|
ASSERT(lpIUnknown!=NULL);
|
|
HRESULT hResult=
|
|
lpIUnknown->QueryInterface(IID_IWebBrowser2,(void**)&m_pIWebBrowser);
|
|
if(!SUCCEEDED(hResult))
|
|
{
|
|
m_pIWebBrowser=NULL;
|
|
m_HTMLBrowserWnd.DestroyWindow();
|
|
}
|
|
}
|
|
}
|
|
|
|
void COXHTMLFileViewer::OnDestroyPreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pPreviewWnd);
|
|
|
|
if(m_pIWebBrowser!=NULL)
|
|
{
|
|
m_pIWebBrowser->Release();
|
|
m_pIWebBrowser=NULL;
|
|
}
|
|
if(::IsWindow(m_HTMLBrowserWnd.GetSafeHwnd()))
|
|
{
|
|
m_HTMLBrowserWnd.DestroyWindow();
|
|
}
|
|
|
|
m_bCanPreview=FALSE;
|
|
}
|
|
|
|
|
|
#endif // OX_PREVIEW_HTML
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef OX_PREVIEW_SOUND
|
|
|
|
BEGIN_MESSAGE_MAP(COXSoundFileViewer::COXSoundFileViewerHelper, CWnd)
|
|
//{{AFX_MSG_MAP(COXSoundFileViewer::COXSoundFileViewerHelper)
|
|
ON_MESSAGE(WM_PAINT,
|
|
COXSoundFileViewer::COXSoundFileViewerHelper::OnPaint)
|
|
ON_BN_CLICKED(IDC_OXSOUNDPREVIEW_BUTTON_START_PLAYING,
|
|
COXSoundFileViewer::COXSoundFileViewerHelper::OnStartPlaying)
|
|
ON_BN_CLICKED(IDC_OXSOUNDPREVIEW_BUTTON_STOP_PLAYING,
|
|
COXSoundFileViewer::COXSoundFileViewerHelper::OnStopPlaying)
|
|
ON_MESSAGE(WM_OX_SOUNDPLAYBACKCOMPLETE,
|
|
COXSoundFileViewer::COXSoundFileViewerHelper::OnPlayComplete)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
LRESULT COXSoundFileViewer::COXSoundFileViewerHelper::OnPaint(WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
UNREFERENCED_PARAMETER(wParam);
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
CPaintDC dc(this);
|
|
|
|
CRect rect;
|
|
GetClientRect(rect);
|
|
dc.FillSolidRect(rect,::GetSysColor(COLOR_BTNFACE));
|
|
|
|
dc.SetBkMode(TRANSPARENT);
|
|
dc.SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
|
|
|
|
static CFont fontText;
|
|
if((HFONT)fontText==NULL)
|
|
{
|
|
VERIFY(fontText.CreatePointFont(80,_T("MS Sans Serif")));
|
|
}
|
|
dc.SelectObject(&fontText);
|
|
dc.DrawText(m_sSoundInfo,m_rectSoundInfo,DT_LEFT|DT_WORDBREAK);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void COXSoundFileViewer::COXSoundFileViewerHelper::OnStartPlaying()
|
|
{
|
|
m_sound.Play(FALSE,TRUE);
|
|
|
|
m_btnStartPlaying.EnableWindow(FALSE);
|
|
m_btnStopPlaying.EnableWindow(TRUE);
|
|
}
|
|
|
|
|
|
void COXSoundFileViewer::COXSoundFileViewerHelper::OnStopPlaying()
|
|
{
|
|
if(m_sound.IsWaveLoaded())
|
|
{
|
|
WAVEFORMATEX wfx;
|
|
|
|
if(m_sound.GetWaveFormat(&wfx))
|
|
{
|
|
CString sStereo, sMono;
|
|
VERIFY(sMono.LoadString(IDS_OX_SOUNDFILEVIEWERMONO));//"Mono"
|
|
VERIFY(sStereo.LoadString(IDS_OX_SOUNDFILEVIEWERSTEREO));//"Stereo"
|
|
m_sSoundInfo.Format(IDS_OX_SOUNDFILEVIEWERRATE, //"%s\nSample rate: %d kHz"
|
|
(wfx.nChannels==1 ? sMono : sStereo),
|
|
wfx.nSamplesPerSec/1000);
|
|
RedrawWindow(m_rectSoundInfo);
|
|
}
|
|
}
|
|
|
|
m_sound.Stop();
|
|
|
|
m_btnStartPlaying.EnableWindow(TRUE);
|
|
m_btnStopPlaying.EnableWindow(FALSE);
|
|
}
|
|
|
|
|
|
LRESULT COXSoundFileViewer::COXSoundFileViewerHelper::OnPlayComplete(WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
UNREFERENCED_PARAMETER(wParam);
|
|
UNREFERENCED_PARAMETER(lParam);
|
|
|
|
OnStopPlaying();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
BOOL COXSoundFileViewer::OnNewFileSelect(const CString& sFilename,
|
|
BOOL bViewerFound/*=FALSE*/)
|
|
{
|
|
COXFilePath pathPreview(sFilename);
|
|
|
|
m_wndHelper.m_sound.Stop();
|
|
|
|
BOOL bSuccess=FALSE;
|
|
if(!bViewerFound && !sFilename.IsEmpty() && pathPreview.Exists())
|
|
{
|
|
if(m_wndHelper.m_sound.CanPlay())
|
|
{
|
|
bSuccess=m_wndHelper.m_sound.Open(sFilename);
|
|
}
|
|
}
|
|
|
|
if(::IsWindow(m_wndHelper.GetSafeHwnd()))
|
|
{
|
|
m_wndHelper.m_btnStartPlaying.EnableWindow(TRUE);
|
|
m_wndHelper.m_btnStopPlaying.EnableWindow(FALSE);
|
|
|
|
m_wndHelper.ShowWindow((bSuccess ? SW_SHOWNA : SW_HIDE));
|
|
}
|
|
|
|
if(!bSuccess)
|
|
{
|
|
m_wndHelper.m_sSoundInfo.Empty();
|
|
}
|
|
|
|
m_bCanPreview=bSuccess;
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
void COXSoundFileViewer::OnCreatePreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
ASSERT(pPreviewWnd!=NULL);
|
|
ASSERT(::IsWindow(pPreviewWnd->GetSafeHwnd()));
|
|
|
|
CRect rect;
|
|
pPreviewWnd->GetClientRect(rect);
|
|
|
|
// create helper window
|
|
ASSERT(!::IsWindow(m_wndHelper.GetSafeHwnd()));
|
|
VERIFY(m_wndHelper.Create(AfxRegisterWndClass(CS_DBLCLKS),_T(""),
|
|
WS_CHILD|WS_CLIPCHILDREN,rect,pPreviewWnd,AFX_IDW_PANE_FIRST));
|
|
m_wndHelper.m_sound.SetCallbackWnd(&m_wndHelper);
|
|
|
|
rect.DeflateRect(OXSOUNDPREVIEW_BORDER_OFFSET,OXSOUNDPREVIEW_BORDER_OFFSET);
|
|
// create buttons for playing the sound
|
|
CRect rectButtonStart=rect;
|
|
rectButtonStart.bottom=rectButtonStart.top+OXSOUNDPREVIEW_BUTTON_HEIGHT;
|
|
rectButtonStart.right=rectButtonStart.left+OXSOUNDPREVIEW_BUTTON_WIDTH;
|
|
VERIFY(m_wndHelper.m_btnStartPlaying.Create(
|
|
_T("4"),WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,rectButtonStart,
|
|
&m_wndHelper,IDC_OXSOUNDPREVIEW_BUTTON_START_PLAYING));
|
|
|
|
CRect rectButtonStop=rectButtonStart;
|
|
rectButtonStop.left=rectButtonStart.right+OXSOUNDPREVIEW_BORDER_OFFSET;
|
|
rectButtonStop.right=rectButtonStop.left+OXSOUNDPREVIEW_BUTTON_WIDTH;
|
|
VERIFY(m_wndHelper.m_btnStopPlaying.Create(
|
|
_T("<"),WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,rectButtonStop,
|
|
&m_wndHelper,IDC_OXSOUNDPREVIEW_BUTTON_START_PLAYING));
|
|
|
|
static CFont fontButton;
|
|
if((HFONT)fontButton==NULL)
|
|
{
|
|
VERIFY(fontButton.CreatePointFont(100,_T("Marlett")));
|
|
}
|
|
m_wndHelper.m_btnStartPlaying.SetFont(&fontButton);
|
|
m_wndHelper.m_btnStopPlaying.SetFont(&fontButton);
|
|
|
|
OnChangeSize();
|
|
}
|
|
|
|
|
|
void COXSoundFileViewer::OnDestroyPreviewWnd(COXPreviewWnd* pPreviewWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pPreviewWnd);
|
|
|
|
ASSERT(::IsWindow(m_wndHelper.GetSafeHwnd()));
|
|
m_wndHelper.DestroyWindow();
|
|
|
|
m_wndHelper.m_rectSoundInfo.SetRectEmpty();
|
|
m_wndHelper.m_sSoundInfo.Empty();
|
|
m_wndHelper.m_sound.Stop();
|
|
|
|
m_bCanPreview=FALSE;
|
|
}
|
|
|
|
|
|
void COXSoundFileViewer::OnPreview(BOOL bPreview)
|
|
{
|
|
if(CanPreview())
|
|
{
|
|
ASSERT(::IsWindow(m_wndHelper.GetSafeHwnd()));
|
|
m_wndHelper.ShowWindow((bPreview ? SW_SHOWNA : SW_HIDE));
|
|
}
|
|
}
|
|
|
|
|
|
void COXSoundFileViewer::OnChangeSize()
|
|
{
|
|
ASSERT(m_pPreviewDialog!=NULL);
|
|
ASSERT(m_pPreviewDialog->GetPreviewWnd()!=NULL);
|
|
|
|
CRect rect;
|
|
m_pPreviewDialog->GetPreviewWnd()->GetClientRect(rect);
|
|
|
|
if(::IsWindow(m_wndHelper.GetSafeHwnd()))
|
|
{
|
|
CSize szWindow(rect.Width(),rect.Height());
|
|
m_wndHelper.MoveWindow(0,0,szWindow.cx,szWindow.cy);
|
|
|
|
rect.DeflateRect(OXSOUNDPREVIEW_BORDER_OFFSET,OXSOUNDPREVIEW_BORDER_OFFSET);
|
|
// calculate the rectangle for the area that can be taken
|
|
// by sound info text
|
|
m_wndHelper.m_rectSoundInfo=rect;
|
|
|
|
CRect rectButton;
|
|
m_wndHelper.m_btnStartPlaying.GetWindowRect(rectButton);
|
|
m_wndHelper.m_rectSoundInfo.top+=rectButton.Height()+
|
|
OXSOUNDPREVIEW_BORDER_OFFSET;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL COXSoundFileViewer::OnPaintPreview(CDC* pDC, const CRect& paintRect)
|
|
{
|
|
UNREFERENCED_PARAMETER(pDC);
|
|
UNREFERENCED_PARAMETER(paintRect);
|
|
|
|
return (CanPreview());
|
|
}
|
|
|
|
|
|
BOOL COXSoundFileViewer::OnDoRealizePalette(CWnd* pFocusWnd)
|
|
{
|
|
UNREFERENCED_PARAMETER(pFocusWnd);
|
|
|
|
return (CanPreview());
|
|
}
|
|
|
|
#endif // OX_PREVIEW_SOUND
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Definition of static members
|
|
|
|
// global array of all preview dialog objects
|
|
CMap<HWND,HWND,COXPreviewDialog*,COXPreviewDialog*>
|
|
COXPreviewDialog::m_allPreviewDialogs;
|
|
|
|
IMPLEMENT_DYNAMIC(COXPreviewDialog, CFileDialog)
|
|
|
|
COXPreviewDialog::COXPreviewDialog(BOOL bOpenFileDialog, LPCTSTR lpszDefExt,
|
|
LPCTSTR lpszFileName, DWORD dwFlags,
|
|
LPCTSTR lpszFilter, CWnd* pParentWnd) :
|
|
CFileDialog(bOpenFileDialog,lpszDefExt,lpszFileName,dwFlags,
|
|
lpszFilter, pParentWnd),
|
|
m_bFlatToolbar(TRUE),
|
|
m_rectPreviewArea(0,0,0,0),
|
|
m_rectSplitterArea(0,0,0,0),
|
|
m_rectResizableArea(0,0,0,0),
|
|
m_bIsSplitterPressed(FALSE),
|
|
m_ptOldSplitterCapture(0,0),
|
|
m_nOldListCtrlWidth(-1),
|
|
m_nOldListCtrlHeight(-1),
|
|
m_pfnSuper(NULL),
|
|
m_nPreviewWndOffset(0),
|
|
m_bPreview(TRUE),
|
|
m_bPrevPreview(TRUE),
|
|
m_sSelectedFile(_T("")),
|
|
m_sPrevSelectedFile(_T("")),
|
|
m_bInitialized(FALSE)
|
|
{
|
|
if(IsOldStyle())
|
|
{
|
|
TRACE(_T("COXPreviewDialog: failed to instantiate the object. OFN_EXPLORER style must be specified"));
|
|
AfxThrowNotSupportedException();
|
|
return;
|
|
}
|
|
|
|
m_preview.m_pPreviewDlg=this;
|
|
|
|
#ifdef OX_PREVIEW_RTF
|
|
VERIFY(AddFileViewer(&m_rtfFileViewer)!=-1);
|
|
#endif
|
|
#ifdef OX_PREVIEW_GRAPHICS
|
|
VERIFY(AddFileViewer(&m_graphicsFileViewer)!=-1);
|
|
#endif
|
|
#ifdef OX_PREVIEW_SOUND
|
|
VERIFY(AddFileViewer(&m_soundFileViewer)!=-1);
|
|
#endif
|
|
#ifdef OX_PREVIEW_HTML
|
|
VERIFY(AddFileViewer(&m_htmlFileViewer)!=-1);
|
|
#endif
|
|
#ifdef OX_PREVIEW_PLAINTEXT
|
|
VERIFY(AddFileViewer(&m_textFileViewer)!=-1);
|
|
#endif
|
|
}
|
|
|
|
|
|
COXPreviewDialog::~COXPreviewDialog()
|
|
{
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(COXPreviewDialog, CFileDialog)
|
|
ON_WM_PALETTECHANGED()
|
|
ON_WM_ACTIVATE()
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
LRESULT CALLBACK COXPreviewDialog::GlobalPreviewDialogProc(HWND hWnd,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
#if defined (_WINDLL)
|
|
#if defined (_AFXDLL)
|
|
AFX_MANAGE_STATE(AfxGetAppModuleState());
|
|
#else
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
#endif
|
|
#endif
|
|
|
|
COXPreviewDialog* pPreviewDlg=NULL;
|
|
if(m_allPreviewDialogs.Lookup(hWnd,pPreviewDlg))
|
|
{
|
|
ASSERT_VALID(pPreviewDlg);
|
|
return pPreviewDlg->PreviewDialogProc(hWnd,uMsg,wParam,lParam);
|
|
}
|
|
else
|
|
{
|
|
return ::DefWindowProc(hWnd,uMsg,wParam,lParam);
|
|
}
|
|
}
|
|
|
|
LRESULT COXPreviewDialog::PreviewDialogProc(HWND hWnd, UINT uMsg,
|
|
WPARAM wParam, LPARAM lParam)
|
|
{
|
|
#if defined (_WINDLL)
|
|
#if defined (_AFXDLL)
|
|
AFX_MANAGE_STATE(AfxGetAppModuleState());
|
|
#else
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
#endif
|
|
#endif
|
|
|
|
ASSERT(!IsOldStyle());
|
|
|
|
LRESULT result = CallWindowProc(m_pfnSuper, hWnd, uMsg, wParam, lParam);
|
|
|
|
// initialize internal variables
|
|
if(!m_bInitialized)
|
|
{
|
|
InitializePreviewDialog();
|
|
}
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_OX_LOAD_PREVIEWWND_OFFSET:
|
|
{
|
|
LoadPreviewWndOffsetState();
|
|
//changed 11/12/1999
|
|
//GetParent()->UnlockWindowUpdate();
|
|
break;
|
|
}
|
|
case WM_SIZE:
|
|
{
|
|
AdjustControls();
|
|
|
|
// notify all file viewers
|
|
for(int nIndex=0; nIndex<GetFileViewerCount(); nIndex++)
|
|
{
|
|
COXFileViewer* pFileViewer=m_arrFileViewers[nIndex];
|
|
ASSERT(pFileViewer!=NULL);
|
|
pFileViewer->OnChangeSize();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_SETCURSOR:
|
|
{
|
|
if(IsInPreviewMode())
|
|
{
|
|
ASSERT(::IsWindow(m_preview.GetSafeHwnd()));
|
|
|
|
CPoint point;
|
|
::GetCursorPos(&point);
|
|
GetParent()->ScreenToClient(&point);
|
|
|
|
if(m_rectSplitterArea.PtInRect(point))
|
|
{
|
|
HCURSOR hCursor=AfxGetApp()->
|
|
LoadCursor(MAKEINTRESOURCE(AFX_IDC_HSPLITBAR));
|
|
if(hCursor==NULL)
|
|
hCursor=::LoadCursor(NULL,IDC_SIZEWE);
|
|
SetCursor(hCursor);
|
|
return TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_GETMINMAXINFO:
|
|
{
|
|
LPMINMAXINFO lpmmi=(LPMINMAXINFO)lParam;
|
|
CRect rect;
|
|
GetParent()->GetWindowRect(rect);
|
|
// list control
|
|
CWnd* pListCtrl=CWnd::FromHandle(FindListCtrl());
|
|
ASSERT(pListCtrl!=NULL);
|
|
CRect rectListCtrl;
|
|
pListCtrl->GetWindowRect(rectListCtrl);
|
|
int nNewMinWidth=rect.Width()-rectListCtrl.Width()+
|
|
OX_MIN_SHELLITEMSLISTCTRL_WIDTH;
|
|
if(nNewMinWidth>lpmmi->ptMinTrackSize.x)
|
|
{
|
|
lpmmi->ptMinTrackSize.x=nNewMinWidth;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
if(IsInPreviewMode())
|
|
{
|
|
ASSERT(::IsWindow(m_preview.GetSafeHwnd()));
|
|
|
|
CPoint point(LOWORD(lParam),HIWORD(lParam));
|
|
if(m_rectSplitterArea.PtInRect(point))
|
|
{
|
|
GetParent()->SetCapture();
|
|
m_ptOldSplitterCapture=point;
|
|
m_bIsSplitterPressed=TRUE;
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_LBUTTONUP:
|
|
{
|
|
if(m_bIsSplitterPressed)
|
|
{
|
|
if(::GetCapture()==GetParent()->GetSafeHwnd())
|
|
{
|
|
::ReleaseCapture();
|
|
}
|
|
m_bIsSplitterPressed=FALSE;
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_CANCELMODE:
|
|
{
|
|
if(m_bIsSplitterPressed)
|
|
{
|
|
if(::GetCapture()==GetParent()->GetSafeHwnd())
|
|
{
|
|
::ReleaseCapture();
|
|
}
|
|
m_bIsSplitterPressed=FALSE;
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_MOUSEMOVE:
|
|
{
|
|
if(m_bIsSplitterPressed)
|
|
{
|
|
CPoint point;
|
|
::GetCursorPos(&point);
|
|
GetParent()->ScreenToClient(&point);
|
|
if(!m_rectResizableArea.PtInRect(point))
|
|
{
|
|
if(point.x<m_rectResizableArea.left)
|
|
{
|
|
point.x=m_rectResizableArea.left;
|
|
}
|
|
else
|
|
{
|
|
point.x=m_rectResizableArea.right;
|
|
}
|
|
}
|
|
if(m_ptOldSplitterCapture.x!=point.x)
|
|
{
|
|
SetPreviewWndOffset(GetPreviewWndOffset()+
|
|
m_ptOldSplitterCapture.x-point.x);
|
|
}
|
|
m_ptOldSplitterCapture=point;
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!::IsWindow(GetSafeHwnd()))
|
|
{
|
|
// remove dialog from the global list of active dialogs
|
|
HWND hWnd=NULL;
|
|
COXPreviewDialog* pDialog=NULL;
|
|
POSITION pos=m_allPreviewDialogs.GetStartPosition();
|
|
while(pos!=NULL)
|
|
{
|
|
m_allPreviewDialogs.GetNextAssoc(pos,hWnd,pDialog);
|
|
if(pDialog==this)
|
|
{
|
|
m_allPreviewDialogs.RemoveKey(hWnd);
|
|
m_pfnSuper=NULL;
|
|
}
|
|
}
|
|
ASSERT(m_pfnSuper==NULL);
|
|
m_bInitialized=FALSE;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
CRect COXPreviewDialog::AdjustRectToFit(CRect rect, CRect rectBound)
|
|
{
|
|
// adjust the rect to fit the size of preview area
|
|
int nWidth=rect.Width();
|
|
int nHeight=rect.Height();
|
|
BOOL bAlignHorz=((rect.Width()*rectBound.Height()) >
|
|
(rect.Height()*rectBound.Width()));
|
|
if(bAlignHorz)
|
|
{
|
|
if(rectBound.Width()<rect.Width())
|
|
{
|
|
nHeight=(rect.Height()*rectBound.Width())/rect.Width();
|
|
nWidth=rectBound.Width();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(rectBound.Height()<rect.Height())
|
|
{
|
|
nWidth=(rect.Width()*rectBound.Height())/rect.Height();
|
|
nHeight=rectBound.Height();
|
|
}
|
|
}
|
|
|
|
ASSERT(rectBound.Height()>=nHeight);
|
|
ASSERT(rectBound.Width()>=nWidth);
|
|
|
|
rect.top+=(rectBound.Height()-nHeight)/2;
|
|
rect.bottom=rect.top+nHeight;
|
|
rect.left+=(rectBound.Width()-nWidth)/2;
|
|
rect.right=rect.left+nWidth;
|
|
|
|
return rect;
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::InitializePreviewDialog()
|
|
{
|
|
ASSERT(!m_bInitialized);
|
|
|
|
CWnd* pListCtrl=CWnd::FromHandle(FindListCtrl());
|
|
if(pListCtrl!=NULL)
|
|
{
|
|
m_bInitialized=TRUE;
|
|
|
|
CRect rectListCtrl;
|
|
pListCtrl->GetWindowRect(rectListCtrl);
|
|
m_nOldListCtrlWidth=rectListCtrl.Width();
|
|
m_nOldListCtrlHeight=rectListCtrl.Height();
|
|
|
|
LoadPreviewState();
|
|
|
|
GetParent()->PostMessage(WM_OX_LOAD_PREVIEWWND_OFFSET);
|
|
}
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::OnNewFileSelect(const CString& sFilename)
|
|
{
|
|
BOOL bViewerFound=FALSE;
|
|
for(int nIndex=0; nIndex<GetFileViewerCount(); nIndex++)
|
|
{
|
|
COXFileViewer* pFileViewer=m_arrFileViewers[nIndex];
|
|
ASSERT(pFileViewer!=NULL);
|
|
if(pFileViewer->OnNewFileSelect(sFilename,bViewerFound))
|
|
{
|
|
bViewerFound=TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
void COXPreviewDialog::OnPaintPreview(CDC* pDC, const CRect& paintRect)
|
|
{
|
|
for(int nIndex=0; nIndex<GetFileViewerCount(); nIndex++)
|
|
{
|
|
COXFileViewer* pFileViewer=m_arrFileViewers[nIndex];
|
|
ASSERT(pFileViewer!=NULL);
|
|
if(pFileViewer->OnPaintPreview(pDC,paintRect))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
DrawPreviewNotAvailable(pDC,paintRect);
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::OnDoRealizePalette(CWnd* pFocusWnd)
|
|
{
|
|
for(int nIndex=0; nIndex<GetFileViewerCount(); nIndex++)
|
|
{
|
|
COXFileViewer* pFileViewer=m_arrFileViewers[nIndex];
|
|
ASSERT(pFileViewer!=NULL);
|
|
if(pFileViewer->OnDoRealizePalette(pFocusWnd))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::DrawPreviewNotAvailable(CDC* pDC, const CRect& paintRect)
|
|
{
|
|
ASSERT(pDC!=NULL);
|
|
|
|
// Paint space of preview
|
|
pDC->FillSolidRect(paintRect,::GetSysColor(COLOR_BTNFACE));
|
|
|
|
CFont* pFont=CFont::FromHandle((HFONT)::GetStockObject(DEFAULT_GUI_FONT));
|
|
CFont* pOldFont=pDC->SelectObject(pFont);
|
|
CRect rect=paintRect;
|
|
pDC->DrawText(_T("Preview not available."),rect,
|
|
DT_CENTER|DT_VCENTER|DT_SINGLELINE);
|
|
pDC->SelectObject(pOldFont);
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::CheckFileSelection()
|
|
{
|
|
CString sFile;
|
|
|
|
if((m_sPrevSelectedFile.CompareNoCase(m_sSelectedFile)!=0) ||
|
|
(m_bPrevPreview!=m_bPreview))
|
|
{
|
|
if(m_bPreview)
|
|
{
|
|
sFile=m_sSelectedFile;
|
|
}
|
|
|
|
OnNewFileSelect(sFile);
|
|
|
|
if(m_bPreview)
|
|
{
|
|
ASSERT(::IsWindow(m_preview.GetSafeHwnd()));
|
|
m_preview.Invalidate(FALSE);
|
|
}
|
|
|
|
m_sPrevSelectedFile=m_sSelectedFile;
|
|
m_bPrevPreview=m_bPreview;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL COXPreviewDialog::OnInitDialog()
|
|
{
|
|
CFileDialog::OnInitDialog();
|
|
|
|
//changed 11/12/1999
|
|
//GetParent()->LockWindowUpdate();
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::OnPaletteChanged(CWnd* pFocusWnd)
|
|
{
|
|
CFileDialog::OnPaletteChanged(pFocusWnd);
|
|
OnDoRealizePalette(pFocusWnd);
|
|
}
|
|
|
|
void COXPreviewDialog::OnActivate(UINT nState, CWnd* pWndOther,
|
|
BOOL bMinimized)
|
|
{
|
|
CFileDialog::OnActivate(nState,pWndOther,bMinimized);
|
|
|
|
if(nState==WA_CLICKACTIVE || nState==WA_ACTIVE)
|
|
{
|
|
OnDoRealizePalette(this);
|
|
}
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::SetPreview(BOOL bPreview)
|
|
{
|
|
BOOL bOldPreview=IsInPreviewMode();
|
|
|
|
if(!::IsWindow(GetSafeHwnd()))
|
|
{
|
|
m_bPreview=bPreview;
|
|
}
|
|
else
|
|
{
|
|
if(bPreview)
|
|
{
|
|
if(!::IsWindow(m_preview.GetSafeHwnd()))
|
|
{
|
|
// resize list control
|
|
CWnd* pListCtrl=CWnd::FromHandle(FindListCtrl());
|
|
ASSERT(pListCtrl!=NULL);
|
|
CRect rectListCtrl;
|
|
pListCtrl->GetWindowRect(rectListCtrl);
|
|
m_rectPreviewArea=rectListCtrl;
|
|
// align right side of the list control with right side of
|
|
// the extended combo box
|
|
CWnd* pExtComboBox=GetParent()->GetDlgItem(cmb2);
|
|
ASSERT(pExtComboBox!=NULL);
|
|
CRect rectExtCombo;
|
|
pExtComboBox->GetWindowRect(rectExtCombo);
|
|
rectListCtrl.right=rectExtCombo.right-GetPreviewWndOffset();
|
|
GetParent()->ScreenToClient(rectListCtrl);
|
|
pListCtrl->MoveWindow(rectListCtrl);
|
|
m_nOldListCtrlWidth=rectListCtrl.Width();
|
|
m_nOldListCtrlHeight=rectListCtrl.Height();
|
|
|
|
// set preview flag to TRUE
|
|
m_bPreview=TRUE;
|
|
// calculate preview rectangle. Its width will be the same as
|
|
// the width of the toolbar and height as list control's height
|
|
CWnd* pToolBar=CWnd::FromHandle(FindToolBar());
|
|
ASSERT(pToolBar!=NULL);
|
|
CRect rectToolBar;
|
|
pToolBar->GetWindowRect(rectToolBar);
|
|
m_rectPreviewArea.left=rectToolBar.left-GetPreviewWndOffset();
|
|
GetParent()->ScreenToClient(m_rectPreviewArea);
|
|
|
|
// check/uncheck "Preview" button
|
|
TBBUTTON button;
|
|
pToolBar->SendMessage(TB_GETBUTTON,
|
|
pToolBar->SendMessage(TB_BUTTONCOUNT)-1,(LPARAM)&button);
|
|
if((button.fsState&TBSTATE_CHECKED)!=(bPreview ? TBSTATE_CHECKED : 0))
|
|
{
|
|
pToolBar->SendMessage(TB_CHECKBUTTON,OX_IDC_SET_PREVIEW,
|
|
MAKELPARAM(bPreview,0));
|
|
}
|
|
|
|
// create preview window
|
|
VERIFY(m_preview.
|
|
Create(GetParent(),m_rectPreviewArea,AFX_IDW_PANE_FIRST));
|
|
|
|
// save "splitter" area coordinates
|
|
m_rectSplitterArea=m_rectPreviewArea;
|
|
int nOldLeftCoord=m_rectSplitterArea.left;
|
|
m_rectSplitterArea.left=rectListCtrl.right;
|
|
m_rectSplitterArea.right=nOldLeftCoord;
|
|
|
|
// save "resizable" area coordinates
|
|
m_rectResizableArea=rectListCtrl;
|
|
m_rectResizableArea.left+=OX_MIN_SHELLITEMSLISTCTRL_WIDTH;
|
|
m_rectResizableArea.right=m_rectPreviewArea.right-
|
|
OX_MIN_PREVIEWWND_WIDTH;
|
|
|
|
// notify all file viewers
|
|
for(int nIndex=0; nIndex<GetFileViewerCount(); nIndex++)
|
|
{
|
|
COXFileViewer* pFileViewer=m_arrFileViewers[nIndex];
|
|
ASSERT(pFileViewer!=NULL);
|
|
pFileViewer->OnCreatePreviewWnd(&m_preview);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(::IsWindow(m_preview.GetSafeHwnd()))
|
|
{
|
|
// notify all file viewers
|
|
for(int nIndex=0; nIndex<GetFileViewerCount(); nIndex++)
|
|
{
|
|
COXFileViewer* pFileViewer=m_arrFileViewers[nIndex];
|
|
ASSERT(pFileViewer!=NULL);
|
|
pFileViewer->OnDestroyPreviewWnd(&m_preview);
|
|
}
|
|
|
|
// destroy preview window
|
|
VERIFY(m_preview.DestroyWindow());
|
|
|
|
// resize list control
|
|
CWnd* pListCtrl=CWnd::FromHandle(FindListCtrl());
|
|
ASSERT(pListCtrl!=NULL);
|
|
CRect rectListCtrl;
|
|
pListCtrl->GetWindowRect(rectListCtrl);
|
|
GetParent()->ClientToScreen(m_rectPreviewArea);
|
|
rectListCtrl.right=m_rectPreviewArea.right;
|
|
GetParent()->ScreenToClient(rectListCtrl);
|
|
pListCtrl->MoveWindow(rectListCtrl);
|
|
m_nOldListCtrlWidth=rectListCtrl.Width();
|
|
m_nOldListCtrlHeight=rectListCtrl.Height();
|
|
}
|
|
|
|
// reset preview area size
|
|
m_rectPreviewArea.SetRectEmpty();
|
|
}
|
|
|
|
// set preview flag
|
|
m_bPreview=bPreview;
|
|
|
|
CheckFileSelection();
|
|
}
|
|
|
|
if(bOldPreview!=IsInPreviewMode())
|
|
{
|
|
CheckFileSelection();
|
|
// notify all file viewers
|
|
for(int nIndex=0; nIndex<GetFileViewerCount(); nIndex++)
|
|
{
|
|
COXFileViewer* pFileViewer=m_arrFileViewers[nIndex];
|
|
ASSERT(pFileViewer!=NULL);
|
|
pFileViewer->OnPreview(IsInPreviewMode());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::OnInitDone()
|
|
{
|
|
CFileDialog::OnInitDone();
|
|
|
|
UpdateToolBar();
|
|
SetFlatToolBar(IsFlatToolBar());
|
|
// subclass parent window
|
|
CWnd* pParentWnd=GetParent();
|
|
ASSERT(pParentWnd!=NULL);
|
|
m_pfnSuper=(WNDPROC)
|
|
(LONG_PTR)
|
|
::SetWindowLongPtr(
|
|
pParentWnd->GetSafeHwnd(),
|
|
GWL_WNDPROC,
|
|
(LONG_PTR)GlobalPreviewDialogProc);
|
|
m_allPreviewDialogs.SetAt(pParentWnd->GetSafeHwnd(),this);
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::OnFolderChange()
|
|
{
|
|
CFileDialog::OnFolderChange();
|
|
|
|
if(m_bPreview)
|
|
{
|
|
// resize list control
|
|
CWnd* pListCtrl=CWnd::FromHandle(FindListCtrl());
|
|
ASSERT(pListCtrl!=NULL);
|
|
CRect rectListCtrl;
|
|
pListCtrl->GetWindowRect(rectListCtrl);
|
|
// align right side of the list control with right side of
|
|
// the extended combo box
|
|
CWnd* pExtComboBox=GetParent()->GetDlgItem(cmb2);
|
|
ASSERT(pExtComboBox!=NULL);
|
|
CRect rectExtCombo;
|
|
pExtComboBox->GetWindowRect(rectExtCombo);
|
|
rectListCtrl.right=rectExtCombo.right-GetPreviewWndOffset();
|
|
GetParent()->ScreenToClient(rectListCtrl);
|
|
pListCtrl->MoveWindow(rectListCtrl);
|
|
m_nOldListCtrlWidth=rectListCtrl.Width();
|
|
m_nOldListCtrlHeight=rectListCtrl.Height();
|
|
|
|
OnFileNameChange();
|
|
}
|
|
}
|
|
|
|
|
|
HWND COXPreviewDialog::FindListCtrl()
|
|
{
|
|
ASSERT(::IsWindow(GetSafeHwnd()));
|
|
|
|
// find toolbar window
|
|
CWnd* pParentWnd=GetParent();
|
|
ASSERT(pParentWnd!=NULL);
|
|
CWnd* pChildWnd=pParentWnd->GetWindow(GW_CHILD);
|
|
while(pChildWnd!=NULL)
|
|
{
|
|
CString sClassName;
|
|
::GetClassName(pChildWnd->GetSafeHwnd(),
|
|
sClassName.GetBuffer(MAX_PATH),MAX_PATH);
|
|
if(sClassName.CompareNoCase(_T("SHELLDLL_DefView"))==0)
|
|
{
|
|
return pChildWnd->GetSafeHwnd();
|
|
}
|
|
else
|
|
{
|
|
pChildWnd=pChildWnd->GetWindow(GW_HWNDNEXT);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
HWND COXPreviewDialog::FindToolBar()
|
|
{
|
|
ASSERT(::IsWindow(GetSafeHwnd()));
|
|
|
|
// find toolbar window
|
|
CWnd* pParentWnd=GetParent();
|
|
ASSERT(pParentWnd!=NULL);
|
|
CWnd* pChildWnd=pParentWnd->GetWindow(GW_CHILD);
|
|
while(pChildWnd!=NULL)
|
|
{
|
|
CString sClassName;
|
|
::GetClassName(pChildWnd->GetSafeHwnd(),
|
|
sClassName.GetBuffer(MAX_PATH),MAX_PATH);
|
|
if(sClassName.CompareNoCase(_T("ToolbarWindow32")) == 0)
|
|
{
|
|
// Make sure we get the horizontal toolbar
|
|
CRect rectClient;
|
|
pChildWnd->GetClientRect(rectClient);
|
|
if (rectClient.Width() > rectClient.Height())
|
|
return pChildWnd->GetSafeHwnd(); // This is the one we want!
|
|
else
|
|
pChildWnd=pChildWnd->GetWindow(GW_HWNDNEXT);
|
|
}
|
|
else
|
|
{
|
|
pChildWnd=pChildWnd->GetWindow(GW_HWNDNEXT);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::SetFlatToolBar(BOOL bFlat)
|
|
{
|
|
ASSERT(!IsOldStyle());
|
|
|
|
m_bFlatToolbar=bFlat;
|
|
|
|
if(::IsWindow(GetSafeHwnd()))
|
|
{
|
|
CWnd* pToolBarWnd=CWnd::FromHandle(FindToolBar());
|
|
if(pToolBarWnd!=NULL)
|
|
{
|
|
pToolBarWnd->ModifyStyle((m_bFlatToolbar ? 0 : TBSTYLE_FLAT),
|
|
(m_bFlatToolbar ? TBSTYLE_FLAT : 0));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::UpdateToolBar()
|
|
{
|
|
ASSERT(::IsWindow(GetSafeHwnd()));
|
|
ASSERT(!IsOldStyle());
|
|
ASSERT(!m_bInitialized);
|
|
|
|
// adjust toolbar
|
|
CWnd* pToolBarWnd=CWnd::FromHandle(FindToolBar());
|
|
ASSERT(pToolBarWnd!=NULL);
|
|
// remove the first button separator
|
|
pToolBarWnd->SendMessage(TB_DELETEBUTTON,0,0);
|
|
|
|
#if _MFC_VER>0x0421
|
|
BOOL bSizable=((GetParent()->GetStyle()&WS_THICKFRAME)==WS_THICKFRAME);
|
|
if(bSizable)
|
|
{
|
|
// set list style in order to display preview button text
|
|
pToolBarWnd->ModifyStyle(0,TBSTYLE_LIST);
|
|
for(int nIndex=0; nIndex<pToolBarWnd->SendMessage(TB_BUTTONCOUNT); nIndex++)
|
|
{
|
|
TBBUTTON button;
|
|
VERIFY(pToolBarWnd->SendMessage(TB_GETBUTTON,nIndex,(LPARAM)&button));
|
|
int nID=button.idCommand;
|
|
if(nID!=ID_SEPARATOR)
|
|
{
|
|
TBBUTTONINFO buttonInfo={ sizeof(TBBUTTONINFO) };
|
|
buttonInfo.dwMask=TBIF_STYLE;
|
|
VERIFY(pToolBarWnd->
|
|
SendMessage(TB_GETBUTTONINFO,nID,(LPARAM)&buttonInfo)!=-1);
|
|
if((buttonInfo.fsStyle & TBSTYLE_AUTOSIZE)==0)
|
|
{
|
|
buttonInfo.fsStyle|=TBSTYLE_AUTOSIZE;
|
|
VERIFY(pToolBarWnd->
|
|
SendMessage(TB_SETBUTTONINFO,nID,(LPARAM)&buttonInfo));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// add button for preview mode
|
|
TBBUTTON button;
|
|
#if _MFC_VER>=0x0420
|
|
// update toolbar image list with new button
|
|
CImageList* pImageList=
|
|
CImageList::FromHandle((HIMAGELIST)pToolBarWnd->SendMessage(TB_GETIMAGELIST));
|
|
ASSERT(pImageList!=NULL);
|
|
CBitmap bitmap;
|
|
VERIFY(bitmap.LoadBitmap(IDB_OX_PREVIEWBUTTON));
|
|
button.iBitmap=pImageList->Add(&bitmap,RGB(192,192,192));
|
|
ASSERT(button.iBitmap!=-1);
|
|
pToolBarWnd->SendMessage(TB_SETIMAGELIST,0,(LPARAM)pImageList->GetSafeHandle());
|
|
#else
|
|
// some number
|
|
button.iBitmap=6;
|
|
#endif
|
|
button.idCommand=OX_IDC_SET_PREVIEW;
|
|
button.fsState=(BYTE)(TBSTATE_ENABLED);
|
|
button.fsStyle=TBSTYLE_CHECK;
|
|
#if _MFC_VER>0x0421
|
|
if(bSizable)
|
|
{
|
|
button.fsStyle|=TBSTYLE_AUTOSIZE;
|
|
}
|
|
#endif
|
|
button.dwData=0;
|
|
CString sItem;
|
|
VERIFY(sItem.LoadString(IDS_OX_PREVIEWDIALOGPRV));//"Preview"
|
|
button.iString=pToolBarWnd->
|
|
SendMessage(TB_ADDSTRING,0,(LPARAM)(LPCTSTR) sItem);
|
|
pToolBarWnd->SendMessage(TB_INSERTBUTTON,
|
|
pToolBarWnd->SendMessage(TB_BUTTONCOUNT,0,0),(LPARAM)&button);
|
|
pToolBarWnd->SendMessage(TB_AUTOSIZE);
|
|
pToolBarWnd->SendMessage(TB_SETBUTTONSIZE,0,MAKELPARAM(24,22));
|
|
|
|
// adjust toolbar and extended combo box positions
|
|
CRect rectToolBar;
|
|
pToolBarWnd->GetWindowRect(rectToolBar);
|
|
rectToolBar.right+=8;
|
|
#if _MFC_VER>0x0421
|
|
if(bSizable)
|
|
{
|
|
rectToolBar.left-=72;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
rectToolBar.left-=6;
|
|
}
|
|
|
|
// extended combo for drives and folders
|
|
CWnd* pExtComboBox=GetParent()->GetDlgItem(cmb2);
|
|
ASSERT(pExtComboBox!=NULL);
|
|
CRect rectExtCombo;
|
|
pExtComboBox->GetWindowRect(rectExtCombo);
|
|
rectExtCombo.right=rectToolBar.left-2;
|
|
|
|
GetParent()->ScreenToClient(rectToolBar);
|
|
pToolBarWnd->MoveWindow(rectToolBar);
|
|
GetParent()->ScreenToClient(rectExtCombo);
|
|
pExtComboBox->MoveWindow(rectExtCombo);
|
|
///////////////////////////////////////////////////
|
|
|
|
// force the toolbar to send command messages to this window
|
|
pToolBarWnd->SendMessage(TB_SETPARENT,(WPARAM)GetSafeHwnd());
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::AdjustControls()
|
|
{
|
|
ASSERT(::IsWindow(GetSafeHwnd()));
|
|
|
|
// parent dialog window
|
|
CWnd* pParentWnd=GetParent();
|
|
ASSERT(pParentWnd!=NULL);
|
|
|
|
// toolbar
|
|
CWnd* pToolBarWnd=CWnd::FromHandle(FindToolBar());
|
|
ASSERT(pToolBarWnd!=NULL);
|
|
CRect rectToolBar;
|
|
pToolBarWnd->GetWindowRect(rectToolBar);
|
|
|
|
// list control
|
|
CWnd* pListCtrl=CWnd::FromHandle(FindListCtrl());
|
|
ASSERT(pListCtrl!=NULL);
|
|
CRect rectListCtrl;
|
|
pListCtrl->GetWindowRect(rectListCtrl);
|
|
ASSERT(rectListCtrl.Width()>=OX_MIN_SHELLITEMSLISTCTRL_WIDTH);
|
|
|
|
// the change margin
|
|
int nChangedWidth=rectListCtrl.Width()-m_nOldListCtrlWidth;
|
|
int nChangedHeight=rectListCtrl.Height()-m_nOldListCtrlHeight;
|
|
m_nOldListCtrlWidth=rectListCtrl.Width();
|
|
m_nOldListCtrlHeight=rectListCtrl.Height();
|
|
|
|
|
|
if (!IsWindows2K())
|
|
{
|
|
// OK button
|
|
CWnd* pOKButtonWnd=pParentWnd->GetDlgItem(IDOK);
|
|
ASSERT(pOKButtonWnd!=NULL);
|
|
CRect rectOKButton;
|
|
pOKButtonWnd->GetWindowRect(rectOKButton);
|
|
rectOKButton.OffsetRect(nChangedWidth,0);
|
|
pParentWnd->ScreenToClient(rectOKButton);
|
|
pOKButtonWnd->MoveWindow(rectOKButton);
|
|
|
|
// Cancel button
|
|
CWnd* pCancelButtonWnd=pParentWnd->GetDlgItem(IDCANCEL);
|
|
ASSERT(pCancelButtonWnd!=NULL);
|
|
CRect rectCancelButton;
|
|
pCancelButtonWnd->GetWindowRect(rectCancelButton);
|
|
rectCancelButton.OffsetRect(nChangedWidth,0);
|
|
pParentWnd->ScreenToClient(rectCancelButton);
|
|
pCancelButtonWnd->MoveWindow(rectCancelButton);
|
|
|
|
// filename edit box
|
|
CWnd* pFilenameEditWnd=pParentWnd->GetDlgItem(edt1);
|
|
ASSERT(pFilenameEditWnd!=NULL);
|
|
CRect rectFilenameEdit;
|
|
pFilenameEditWnd->GetWindowRect(rectFilenameEdit);
|
|
rectFilenameEdit.right+=nChangedWidth;
|
|
pParentWnd->ScreenToClient(rectFilenameEdit);
|
|
pFilenameEditWnd->MoveWindow(rectFilenameEdit);
|
|
|
|
// filetype combo box
|
|
CWnd* pFiletypeComboWnd=pParentWnd->GetDlgItem(cmb1);
|
|
ASSERT(pFiletypeComboWnd!=NULL);
|
|
CRect rectFiletypeCombo;
|
|
pFiletypeComboWnd->GetWindowRect(rectFiletypeCombo);
|
|
rectFiletypeCombo.right+=nChangedWidth;
|
|
pParentWnd->ScreenToClient(rectFiletypeCombo);
|
|
pFiletypeComboWnd->MoveWindow(rectFiletypeCombo);
|
|
|
|
}
|
|
// align toolbar with right side of the parent window
|
|
pParentWnd->ScreenToClient(rectToolBar);
|
|
CRect rectClient;
|
|
pParentWnd->GetClientRect(rectClient);
|
|
if(rectToolBar.right!=rectClient.right-2)
|
|
{
|
|
rectToolBar.OffsetRect(rectClient.right-2-rectToolBar.right,0);
|
|
pToolBarWnd->MoveWindow(rectToolBar);
|
|
}
|
|
pParentWnd->ClientToScreen(rectToolBar);
|
|
|
|
// resize extended combo box
|
|
CWnd* pExtComboBox=pParentWnd->GetDlgItem(cmb2);
|
|
ASSERT(pExtComboBox!=NULL);
|
|
CRect rectExtCombo;
|
|
pExtComboBox->GetWindowRect(rectExtCombo);
|
|
rectExtCombo.right=rectToolBar.left-2;
|
|
pParentWnd->ScreenToClient(rectExtCombo);
|
|
pExtComboBox->MoveWindow(rectExtCombo);
|
|
|
|
// update preview area
|
|
if(IsInPreviewMode() && ::IsWindow(m_preview.GetSafeHwnd()))
|
|
{
|
|
m_rectPreviewArea.OffsetRect(nChangedWidth,0);
|
|
m_rectPreviewArea.bottom+=nChangedHeight;
|
|
m_preview.MoveWindow(m_rectPreviewArea);
|
|
m_preview.Invalidate(FALSE);
|
|
|
|
// update "splitter" area coordinates
|
|
m_rectSplitterArea.OffsetRect(nChangedWidth,0);
|
|
m_rectSplitterArea.bottom+=nChangedHeight;
|
|
|
|
// update "resizable" area coordinates
|
|
m_rectResizableArea.InflateRect(0,0,nChangedWidth,nChangedHeight);
|
|
}
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::OnFileNameChange()
|
|
// Notification for Windows 95 and Windows NT 4.0
|
|
{
|
|
int nFileCount;
|
|
CString sPreviewFile;
|
|
|
|
sPreviewFile=GetPathName();
|
|
COXFilePath pathPreview(sPreviewFile);
|
|
if(sPreviewFile.IsEmpty())
|
|
{
|
|
nFileCount=0;
|
|
}
|
|
else if(pathPreview.Exists())
|
|
{
|
|
nFileCount = 1;
|
|
}
|
|
else
|
|
{
|
|
nFileCount=MORE_THAN_ONE;
|
|
}
|
|
|
|
if(nFileCount==1)
|
|
{
|
|
m_sSelectedFile=pathPreview.GetPath();
|
|
}
|
|
else
|
|
{
|
|
m_sSelectedFile.Empty();
|
|
}
|
|
|
|
CheckFileSelection();
|
|
}
|
|
|
|
|
|
BOOL COXPreviewDialog::OnWndMsg(UINT message,WPARAM wParam,
|
|
LPARAM lParam,LRESULT* pResult)
|
|
{
|
|
if(message==WM_NOTIFY)
|
|
{
|
|
NMHDR* pNMHDR=(NMHDR*)lParam;
|
|
if(pNMHDR->hwndFrom==FindToolBar())
|
|
{
|
|
*pResult=GetParent()->SendMessage(message,wParam,lParam);
|
|
return TRUE;
|
|
}
|
|
// tooltip support
|
|
if(pNMHDR->code==TTN_NEEDTEXTA || pNMHDR->code==TTN_NEEDTEXTW)
|
|
{
|
|
// need to handle both ANSI and UNICODE versions of the message
|
|
TOOLTIPTEXTA* pTTTA=(TOOLTIPTEXTA*)pNMHDR;
|
|
TOOLTIPTEXTW* pTTTW=(TOOLTIPTEXTW*)pNMHDR;
|
|
CString sToolTipText;
|
|
VERIFY(sToolTipText.LoadString(IDS_OX_PREVIEWDIALOGTOOLTIP));//"Preview selected file"
|
|
UINT_PTR nID=pNMHDR->idFrom;
|
|
if(pNMHDR->code==TTN_NEEDTEXTA && (pTTTA->uFlags & TTF_IDISHWND) ||
|
|
pNMHDR->code==TTN_NEEDTEXTW && (pTTTW->uFlags & TTF_IDISHWND))
|
|
{
|
|
// idFrom is actually the HWND of the tool
|
|
nID=::GetDlgCtrlID((HWND)nID);
|
|
}
|
|
|
|
// tooltip for preview button
|
|
if(nID==OX_IDC_SET_PREVIEW)
|
|
{
|
|
#ifndef _UNICODE
|
|
if (pNMHDR->code==TTN_NEEDTEXTA)
|
|
{
|
|
lstrcpyn(pTTTA->szText,sToolTipText,
|
|
sizeof(pTTTA->szText)/sizeof(pTTTA->szText[0]));
|
|
}
|
|
else
|
|
{
|
|
_mbstowcsz(pTTTW->szText,sToolTipText,
|
|
sizeof(pTTTW->szText)/sizeof(pTTTW->szText[0]));
|
|
}
|
|
#else
|
|
if (pNMHDR->code==TTN_NEEDTEXTA)
|
|
{
|
|
_wcstombsz(pTTTA->szText,sToolTipText,
|
|
sizeof(pTTTA->szText)/sizeof(pTTTA->szText[0]));
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(pTTTW->szText,sToolTipText,
|
|
sizeof(pTTTW->szText)/sizeof(pTTTW->szText[0]));
|
|
}
|
|
#endif
|
|
*pResult=0;
|
|
|
|
// bring the tooltip window above other popup windows
|
|
::SetWindowPos(pNMHDR->hwndFrom, HWND_TOP, 0, 0, 0, 0,
|
|
SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOOWNERZORDER);
|
|
|
|
return TRUE; // message was handled
|
|
}
|
|
|
|
*pResult=GetParent()->SendMessage(message,wParam,lParam);
|
|
return TRUE;
|
|
}
|
|
}
|
|
else if(message==WM_DESTROY)
|
|
{
|
|
SaveState();
|
|
}
|
|
|
|
return CFileDialog::OnWndMsg(message,wParam,lParam,pResult);
|
|
}
|
|
|
|
|
|
BOOL COXPreviewDialog::OnCommand(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if(wParam==OX_IDC_SET_PREVIEW)
|
|
{
|
|
SetPreview(!IsInPreviewMode());
|
|
return TRUE;
|
|
}
|
|
return (BOOL)GetParent()->SendMessage(WM_COMMAND,wParam,lParam);
|
|
}
|
|
|
|
|
|
BOOL COXPreviewDialog::InsertFileViewer(COXFileViewer* pFileViewer, int nIndex)
|
|
{
|
|
ASSERT(pFileViewer!=NULL);
|
|
int nFileViewerCount=GetFileViewerCount();
|
|
ASSERT(nIndex>=0 && nIndex<=nFileViewerCount);
|
|
|
|
m_arrFileViewers.Add(NULL);
|
|
for(int nViewerIndex=nFileViewerCount-1; nViewerIndex>=nIndex; nViewerIndex--)
|
|
{
|
|
m_arrFileViewers.SetAt(nViewerIndex+1,m_arrFileViewers[nViewerIndex]);
|
|
}
|
|
m_arrFileViewers.SetAt(nIndex,pFileViewer);
|
|
pFileViewer->m_pPreviewDialog=this;
|
|
|
|
if(::IsWindow(m_preview.GetSafeHwnd()) && m_preview.IsWindowVisible())
|
|
{
|
|
m_preview.RedrawWindow();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL COXPreviewDialog::RemoveFileViewer(int nIndex)
|
|
{
|
|
int nFileViewerCount=GetFileViewerCount();
|
|
ASSERT(nIndex>=0 && nIndex<=nFileViewerCount);
|
|
|
|
for(int nViewerIndex=nIndex+1; nViewerIndex<nFileViewerCount; nViewerIndex++)
|
|
{
|
|
m_arrFileViewers.SetAt(nViewerIndex-1,m_arrFileViewers[nViewerIndex]);
|
|
}
|
|
m_arrFileViewers.RemoveAt(nFileViewerCount-1);
|
|
|
|
if(::IsWindow(m_preview.GetSafeHwnd()) && m_preview.IsWindowVisible())
|
|
{
|
|
m_preview.RedrawWindow();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
COXFileViewer* COXPreviewDialog::GetFileViewer(int nIndex) const
|
|
{
|
|
ASSERT(nIndex>=0 && nIndex<=GetFileViewerCount());
|
|
return m_arrFileViewers[nIndex];
|
|
}
|
|
|
|
|
|
int COXPreviewDialog::SetPreviewWndOffset(int nPreviewWndOffset)
|
|
{
|
|
int nDifference=nPreviewWndOffset-GetPreviewWndOffset();
|
|
if(::IsWindow(m_preview.GetSafeHwnd()) &&
|
|
m_preview.IsWindowVisible() && nDifference!=0)
|
|
{
|
|
// resize preview window and list control
|
|
//
|
|
CWnd* pListCtrl=CWnd::FromHandle(FindListCtrl());
|
|
ASSERT(pListCtrl!=NULL);
|
|
CRect rectListCtrl;
|
|
pListCtrl->GetWindowRect(rectListCtrl);
|
|
GetParent()->ScreenToClient(rectListCtrl);
|
|
rectListCtrl.right-=nDifference;
|
|
if(rectListCtrl.right<rectListCtrl.left+OX_MIN_SHELLITEMSLISTCTRL_WIDTH)
|
|
{
|
|
nPreviewWndOffset-=rectListCtrl.left-rectListCtrl.right+
|
|
OX_MIN_SHELLITEMSLISTCTRL_WIDTH;
|
|
nDifference=nPreviewWndOffset-GetPreviewWndOffset();
|
|
rectListCtrl.right=rectListCtrl.left+OX_MIN_SHELLITEMSLISTCTRL_WIDTH;
|
|
}
|
|
else if(rectListCtrl.right>m_rectPreviewArea.right-OX_MIN_PREVIEWWND_WIDTH)
|
|
{
|
|
nPreviewWndOffset+=rectListCtrl.right-m_rectPreviewArea.right+
|
|
OX_MIN_PREVIEWWND_WIDTH;
|
|
nDifference=nPreviewWndOffset-GetPreviewWndOffset();
|
|
rectListCtrl.right=m_rectPreviewArea.right-OX_MIN_PREVIEWWND_WIDTH;
|
|
}
|
|
|
|
if(nDifference!=0)
|
|
{
|
|
pListCtrl->MoveWindow(rectListCtrl);
|
|
m_nOldListCtrlWidth=rectListCtrl.Width();
|
|
|
|
m_rectPreviewArea.left-=nDifference;
|
|
m_preview.MoveWindow(m_rectPreviewArea);
|
|
m_preview.Invalidate(FALSE);
|
|
|
|
m_rectSplitterArea.OffsetRect(-nDifference,0);
|
|
|
|
// notify all file viewers
|
|
for(int nIndex=0; nIndex<GetFileViewerCount(); nIndex++)
|
|
{
|
|
COXFileViewer* pFileViewer=m_arrFileViewers[nIndex];
|
|
ASSERT(pFileViewer!=NULL);
|
|
pFileViewer->OnChangeSize();
|
|
}
|
|
}
|
|
}
|
|
|
|
m_nPreviewWndOffset=nPreviewWndOffset;
|
|
|
|
return GetPreviewWndOffset();
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::SaveState(LPCTSTR lpszProfileName/*=_T("COXPreviewDialog Settings")*/)
|
|
{
|
|
CString sProfileName(lpszProfileName);
|
|
ASSERT(!sProfileName.IsEmpty());
|
|
CWinApp* pApp=AfxGetApp();
|
|
ASSERT(pApp!=NULL);
|
|
pApp->WriteProfileInt(lpszProfileName,_T("Preview"),IsInPreviewMode());
|
|
pApp->WriteProfileInt(lpszProfileName,_T("Preview Window Offset"),
|
|
GetPreviewWndOffset());
|
|
}
|
|
|
|
|
|
void COXPreviewDialog::LoadPreviewState(LPCTSTR lpszProfileName/*=_T("COXPreviewDialog Settings")*/)
|
|
{
|
|
CString sProfileName(lpszProfileName);
|
|
ASSERT(!sProfileName.IsEmpty());
|
|
CWinApp* pApp=AfxGetApp();
|
|
ASSERT(pApp!=NULL);
|
|
BOOL bPreview=(BOOL)pApp->GetProfileInt(lpszProfileName,
|
|
_T("Preview"),IsInPreviewMode());
|
|
SetPreview(bPreview);
|
|
}
|
|
|
|
void COXPreviewDialog::LoadPreviewWndOffsetState(LPCTSTR lpszProfileName/*=_T("COXPreviewDialog Settings")*/)
|
|
{
|
|
CString sProfileName(lpszProfileName);
|
|
ASSERT(!sProfileName.IsEmpty());
|
|
CWinApp* pApp=AfxGetApp();
|
|
ASSERT(pApp!=NULL);
|
|
int nOffset=(int)pApp->GetProfileInt(lpszProfileName,
|
|
_T("Preview Window Offset"),GetPreviewWndOffset());
|
|
SetPreviewWndOffset(nOffset);
|
|
}
|
|
|
|
|
|
|
|
BOOL COXPreviewDialog::IsWindows2K()
|
|
{
|
|
OSVERSIONINFO VersionInfo;
|
|
|
|
::ZeroMemory(&VersionInfo, sizeof(VersionInfo));
|
|
VersionInfo.dwOSVersionInfoSize=sizeof(VersionInfo);
|
|
::GetVersionEx(&VersionInfo);
|
|
if (VersionInfo.dwMajorVersion>4)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|