2022 lines
54 KiB
C++
2022 lines
54 KiB
C++
// pbrusvw.cpp : implementation of the CPBView class
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "global.h"
|
|
#include "pbrush.h"
|
|
#include "pbrusdoc.h"
|
|
#include "pbrusfrm.h"
|
|
#include "pbrusvw.h"
|
|
#include "ipframe.h"
|
|
#include "minifwnd.h"
|
|
#include "bmobject.h"
|
|
#include "imgsuprt.h"
|
|
#include "imgwnd.h"
|
|
#include "imgcolor.h"
|
|
#include "imgbrush.h"
|
|
#include "imageatt.h"
|
|
#include "undo.h"
|
|
#include "props.h"
|
|
#include "imgwell.h"
|
|
#include "imgtools.h"
|
|
#include "imgdlgs.h"
|
|
#include "toolbox.h"
|
|
#include "thumnail.h"
|
|
#include "t_text.h"
|
|
#include "cmpmsg.h"
|
|
#include "printres.h"
|
|
#include "settings.h"
|
|
#include "colorsrc.h"
|
|
#include "cderr.h"
|
|
#include "srvritem.h"
|
|
|
|
#include <regstr.h>
|
|
|
|
#ifdef USE_PRINTDLGEX
|
|
#include <afxprntx.h>
|
|
#include <dlgprnt2.cpp>
|
|
#endif //USE_PRINTDLGEX
|
|
|
|
#if 0 // THIS_FILE is already declared in dlgprnt2.cpp
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static CHAR BASED_CODE THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#endif
|
|
|
|
IMPLEMENT_DYNCREATE(CPBView, CView)
|
|
|
|
#include "memtrace.h"
|
|
|
|
|
|
/***************************************************************************/
|
|
// CPBView
|
|
|
|
BEGIN_MESSAGE_MAP(CPBView, CView)
|
|
//{{AFX_MSG_MAP(CPBView)
|
|
ON_WM_CREATE()
|
|
ON_WM_SIZE()
|
|
ON_COMMAND(ID_EDIT_UNDO, OnEditUndo)
|
|
ON_COMMAND(ID_EDIT_REDO, OnEditRedo)
|
|
ON_COMMAND(ID_EDIT_CUT, OnEditCut)
|
|
ON_COMMAND(ID_EDIT_CLEAR, OnEditClear)
|
|
ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
|
|
ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateEditUndo)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_REDO, OnUpdateEditRedo)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
|
|
ON_COMMAND(ID_VIEW_GRID, OnViewGrid)
|
|
ON_COMMAND(ID_VIEW_ZOOM_100, OnViewZoom100)
|
|
ON_COMMAND(ID_VIEW_ZOOM_400, OnViewZoom400)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM_100, OnUpdateViewZoom100)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_ZOOM_400, OnUpdateViewZoom400)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_GRID, OnUpdateViewGrid)
|
|
ON_COMMAND(ID_IMAGE_INVERT_COLORS, OnImageInvertColors)
|
|
ON_UPDATE_COMMAND_UI(ID_IMAGE_INVERT_COLORS, OnUpdateImageInvertColors)
|
|
ON_COMMAND(IDM_TGLOPAQUE, OnTglopaque)
|
|
ON_UPDATE_COMMAND_UI(IDM_TGLOPAQUE, OnUpdateTglopaque)
|
|
ON_COMMAND(ID_IMAGE_ATTRIBUTES, OnImageAttributes)
|
|
ON_COMMAND(IDMX_SEL2BSH, OnSel2bsh)
|
|
ON_COMMAND(IDMX_LARGERBRUSH, OnLargerbrush)
|
|
ON_COMMAND(IDMX_SMALLERBRUSH, OnSmallerbrush)
|
|
ON_COMMAND(ID_VIEW_ZOOM, OnViewZoom)
|
|
ON_COMMAND(ID_IMAGE_FLIP_ROTATE, OnImageFlipRotate)
|
|
ON_UPDATE_COMMAND_UI(ID_IMAGE_FLIP_ROTATE, OnUpdateImageFlipRotate)
|
|
ON_COMMAND(IDM_EDITCOLORS, OnEditcolors)
|
|
ON_UPDATE_COMMAND_UI(IDM_EDITCOLORS, OnUpdateEditcolors)
|
|
#if 0
|
|
ON_COMMAND(IDM_LOADCOLORS, OnLoadcolors)
|
|
ON_UPDATE_COMMAND_UI(IDM_LOADCOLORS, OnUpdateLoadcolors)
|
|
ON_COMMAND(IDM_SAVECOLORS, OnSavecolors)
|
|
ON_UPDATE_COMMAND_UI(IDM_SAVECOLORS, OnUpdateSavecolors)
|
|
#endif
|
|
ON_COMMAND(ID_EDIT_SELECT_ALL, OnEditSelectAll)
|
|
ON_COMMAND(ID_EDIT_PASTE_FROM, OnEditPasteFrom)
|
|
ON_COMMAND(ID_EDIT_COPY_TO, OnEditCopyTo)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_COPY_TO, OnUpdateEditCopyTo)
|
|
ON_COMMAND(ID_IMAGE_STRETCH_SKEW, OnImageStretchSkew)
|
|
ON_UPDATE_COMMAND_UI(ID_IMAGE_STRETCH_SKEW, OnUpdateImageStretchSkew)
|
|
ON_COMMAND(ID_VIEW_VIEW_PICTURE, OnViewViewPicture)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_VIEW_PICTURE, OnUpdateViewViewPicture)
|
|
ON_COMMAND(ID_VIEW_TEXT_TOOLBAR, OnViewTextToolbar)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_TEXT_TOOLBAR, OnUpdateViewTextToolbar)
|
|
ON_COMMAND(ID_FILE_SETASWALLPAPER_T, OnFileSetaswallpaperT)
|
|
ON_UPDATE_COMMAND_UI(ID_FILE_SETASWALLPAPER_T, OnUpdateFileSetaswallpaperT)
|
|
ON_COMMAND(ID_FILE_SETASWALLPAPER_C, OnFileSetaswallpaperC)
|
|
ON_UPDATE_COMMAND_UI(ID_FILE_SETASWALLPAPER_C, OnUpdateFileSetaswallpaperC)
|
|
ON_COMMAND(ID_VIEW_THUMBNAIL, OnViewThumbnail)
|
|
ON_UPDATE_COMMAND_UI(ID_VIEW_THUMBNAIL, OnUpdateViewThumbnail)
|
|
ON_UPDATE_COMMAND_UI(ID_IMAGE_ATTRIBUTES, OnUpdateImageAttributes)
|
|
ON_COMMAND(ID_ESCAPE, OnEscape)
|
|
ON_COMMAND(ID_ESCAPE_SERVER, OnEscapeServer)
|
|
ON_WM_SHOWWINDOW()
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditSelection)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_CLEAR, OnUpdateEditClearSel)
|
|
ON_COMMAND(ID_FILE_PAGE_SETUP, OnFilePageSetup)
|
|
ON_COMMAND(ID_IMAGE_CLEAR_IMAGE, OnImageClearImage)
|
|
ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateEditClearSel)
|
|
ON_UPDATE_COMMAND_UI(ID_IMAGE_CLEAR_IMAGE, OnUpdateImageClearImage)
|
|
//}}AFX_MSG_MAP
|
|
|
|
ON_WM_DESTROY()
|
|
|
|
|
|
|
|
// Standard printing commands
|
|
ON_COMMAND(ID_FILE_PRINT, OnFilePrint)
|
|
ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview)
|
|
|
|
END_MESSAGE_MAP()
|
|
|
|
/***************************************************************************/
|
|
// CPBView construction/destruction
|
|
|
|
CPBView::CPBView()
|
|
{
|
|
m_pImgWnd = NULL;
|
|
|
|
m_pwndThumbNailFloat = NULL;
|
|
m_pwndThumbNailView = NULL;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
CPBView::~CPBView()
|
|
{
|
|
// reset the toolbar
|
|
if (g_pImgToolWnd && g_pImgToolWnd->m_hWnd &&
|
|
IsWindow(g_pImgToolWnd->m_hWnd) )
|
|
{
|
|
g_pImgToolWnd->SelectTool( IDMB_ARROW );
|
|
g_pImgToolWnd->InvalidateOptions();
|
|
}
|
|
|
|
DestroyThumbNailView();
|
|
|
|
if (m_pImgWnd)
|
|
{
|
|
delete m_pImgWnd;
|
|
m_pImgWnd = NULL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL CPBView::PreCreateWindow( CREATESTRUCT& cs )
|
|
{
|
|
cs.style |= WS_CLIPCHILDREN;
|
|
cs.dwExStyle |= WS_EX_CLIENTEDGE;
|
|
|
|
return CView::PreCreateWindow( cs );
|
|
}
|
|
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL CPBView::PreTranslateMessage(MSG *pMsg)
|
|
{
|
|
// Handle a bug in MFC regarding enabling of accelerators on Popup menus.
|
|
if ( pMsg->message == WM_KEYDOWN )
|
|
{
|
|
// Find the app menu for this window.
|
|
CWnd *pWnd = this;
|
|
CMenu *pMenu = NULL;
|
|
while( pWnd )
|
|
{
|
|
if ( (pMenu = pWnd->GetMenu()) && IsMenu(pMenu->m_hMenu) )
|
|
break;
|
|
else
|
|
pMenu = NULL;
|
|
pWnd = pWnd->GetParent();
|
|
}
|
|
|
|
if ( pMenu )
|
|
{
|
|
pMenu->EnableMenuItem( ID_VIEW_ZOOM_100, MF_BYCOMMAND |
|
|
(m_pImgWnd && m_pImgWnd->GetZoom() != 1 ? MF_ENABLED : MF_DISABLED) );
|
|
pMenu->EnableMenuItem( ID_VIEW_ZOOM_400, MF_BYCOMMAND |
|
|
(m_pImgWnd && m_pImgWnd->GetZoom() != 4 ? MF_ENABLED : MF_DISABLED) );
|
|
pMenu->EnableMenuItem( ID_VIEW_GRID, MF_BYCOMMAND |
|
|
(m_pImgWnd && m_pImgWnd->GetZoom() > 2 ? MF_ENABLED : MF_DISABLED) );
|
|
}
|
|
}
|
|
|
|
return CView::PreTranslateMessage(pMsg);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// CPBView drawing
|
|
|
|
void CPBView::OnDraw( CDC* pDC )
|
|
{
|
|
if (m_pImgWnd)
|
|
{
|
|
CRect rectPaint;
|
|
CPalette* ppal = m_pImgWnd->SetImgPalette( pDC, FALSE );
|
|
|
|
// if the dc passed in is a CPaint DC use the rcPaint rect to optimize
|
|
// painting to only paint the invalid area. ELSE use the whole image
|
|
// size.
|
|
if (pDC->IsKindOf( RUNTIME_CLASS( CPaintDC ) ) )
|
|
{
|
|
rectPaint = ((CPaintDC *)pDC)->m_ps.rcPaint;
|
|
if ( theApp.m_bEmbedded )
|
|
m_pImgWnd->Invalidate();
|
|
}
|
|
else
|
|
{
|
|
m_pImgWnd->GetImageRect( rectPaint );
|
|
}
|
|
|
|
m_pImgWnd->DrawImage( pDC, &rectPaint );
|
|
|
|
if (ppal)
|
|
pDC->SelectPalette( ppal, FALSE );
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// CPBView printing
|
|
|
|
BOOL CPBView::GetPrintToInfo(CPrintInfo* pInfo)
|
|
{
|
|
|
|
ASSERT(pInfo != NULL);
|
|
ASSERT(pInfo->m_pPD != NULL);
|
|
|
|
if (theApp.m_strPrinterName.IsEmpty())
|
|
return FALSE;
|
|
|
|
ASSERT(pInfo->m_pPD->m_pd.hDC == NULL);
|
|
pInfo->m_pPD->m_pd.hDC = ::CreateDC(NULL,
|
|
theApp.m_strPrinterName,
|
|
NULL, NULL);
|
|
|
|
// set up From and To page range from Min and Max
|
|
pInfo->m_pPD->m_pd.nFromPage = (WORD)pInfo->GetMinPage();
|
|
pInfo->m_pPD->m_pd.nToPage = (WORD)pInfo->GetMaxPage();
|
|
|
|
ASSERT(pInfo->m_pPD != NULL);
|
|
ASSERT(pInfo->m_pPD->m_pd.hDC != NULL);
|
|
|
|
pInfo->m_nNumPreviewPages = theApp.m_nNumPreviewPages;
|
|
VERIFY(pInfo->m_strPageDesc.LoadString(AFX_IDS_PREVIEWPAGEDESC));
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CPBView::OnPreparePrinting( CPrintInfo* pInfo )
|
|
{
|
|
#ifdef USE_PRINTDLGEX
|
|
|
|
|
|
//
|
|
// Create a C_PrintDialogEx structure to replace the PrintDialog in the
|
|
// CPrintInfo
|
|
//
|
|
|
|
|
|
m_pdRestore= pInfo->m_pPD;
|
|
m_pdexSub = new C_PrintDialogEx (FALSE, PD_RETURNDC |
|
|
PD_ALLPAGES | PD_NOCURRENTPAGE | PD_NOPAGENUMS |
|
|
PD_NOSELECTION | PD_USEDEVMODECOPIESANDCOLLATE);
|
|
pInfo->m_pPD = m_pdexSub;
|
|
|
|
// These next 2 lines copied from mfc42 source to initialize the printdialog
|
|
//
|
|
pInfo->SetMinPage (1);
|
|
pInfo->SetMaxPage (0xffff);
|
|
|
|
pInfo->m_pPD->m_pd.nFromPage = 1;
|
|
pInfo->m_pPD->m_pd.nToPage = 1;
|
|
|
|
#endif //USE_PRINTDLGEX
|
|
|
|
new CPrintResObj( this, pInfo );
|
|
|
|
if (pInfo->m_lpUserData == NULL)
|
|
return FALSE;
|
|
|
|
if (theApp.m_bPrintOnly)
|
|
{
|
|
if (GetPrintToInfo(pInfo))
|
|
{
|
|
return(TRUE);
|
|
}
|
|
|
|
if (! theApp.GetPrinterDeviceDefaults( &pInfo->m_pPD->m_pd ))
|
|
{
|
|
// bring up dialog to alert the user they need to install a printer.
|
|
if (theApp.DoPrintDialog( pInfo->m_pPD ) != IDOK)
|
|
return FALSE;
|
|
}
|
|
|
|
if (! pInfo->m_pPD->m_pd.hDC)
|
|
{
|
|
// call CreatePrinterDC if DC was not created by above
|
|
if (! pInfo->m_pPD->CreatePrinterDC())
|
|
return FALSE;
|
|
}
|
|
|
|
// set up From and To page range from Min and Max
|
|
pInfo->m_pPD->m_pd.nFromPage = (WORD)pInfo->GetMinPage();
|
|
pInfo->m_pPD->m_pd.nToPage = (WORD)pInfo->GetMaxPage();
|
|
pInfo->m_nNumPreviewPages = theApp.m_nNumPreviewPages;
|
|
return TRUE;
|
|
}
|
|
|
|
// default preparation
|
|
if (! DoPreparePrinting( pInfo ))
|
|
{
|
|
((CPrintResObj*)pInfo->m_lpUserData)->EndPrinting( NULL, pInfo );
|
|
pInfo->m_lpUserData = NULL;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnBeginPrinting( CDC* pDC, CPrintInfo* pInfo )
|
|
{
|
|
|
|
if (pInfo != NULL
|
|
&& pInfo->m_lpUserData != NULL)
|
|
((CPrintResObj*)pInfo->m_lpUserData)->BeginPrinting( pDC, pInfo );
|
|
else
|
|
CView::OnBeginPrinting( pDC, pInfo );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnPrepareDC( CDC* pDC, CPrintInfo* pInfo )
|
|
{
|
|
|
|
#ifdef USE_MIRRORING
|
|
//
|
|
// Disable RTL mirroring
|
|
//
|
|
if (PBGetLayout(pDC->GetSafeHdc()) & LAYOUT_RTL)
|
|
{
|
|
PBSetLayout(pDC->GetSafeHdc(), 0);
|
|
}
|
|
#endif
|
|
|
|
CView::OnPrepareDC( pDC, pInfo );
|
|
|
|
if (pInfo != NULL
|
|
&& pInfo->m_lpUserData != NULL)
|
|
((CPrintResObj*)pInfo->m_lpUserData)->PrepareDC( pDC, pInfo );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnPrint( CDC* pDC, CPrintInfo* pInfo )
|
|
{
|
|
|
|
BOOL bProcessed = FALSE;
|
|
|
|
if (pInfo != NULL
|
|
&& pInfo->m_lpUserData != NULL)
|
|
bProcessed = ((CPrintResObj*)pInfo->m_lpUserData)->PrintPage( pDC, pInfo );
|
|
|
|
if (! bProcessed)
|
|
CView::OnPrint( pDC, pInfo );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEndPrinting( CDC* pDC, CPrintInfo* pInfo )
|
|
{
|
|
|
|
if (pInfo == NULL)
|
|
return;
|
|
|
|
if (pInfo->m_lpUserData != NULL)
|
|
{
|
|
((CPrintResObj*)pInfo->m_lpUserData)->EndPrinting( pDC, pInfo );
|
|
pInfo->m_lpUserData = NULL;
|
|
}
|
|
#ifdef USE_PRINTDLGEX
|
|
//
|
|
// Restore the original dialog pointer
|
|
//
|
|
pInfo->m_pPD = m_pdRestore;
|
|
delete m_pdexSub;
|
|
#endif //USE_PRINTDLGEX
|
|
}
|
|
|
|
/******************************************************************************/
|
|
|
|
// CPBView diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CPBView::AssertValid() const
|
|
{
|
|
CView::AssertValid();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::Dump( CDumpContext& dc ) const
|
|
{
|
|
CView::Dump( dc );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
CPBDoc* CPBView::GetDocument() // non-debug version is inline
|
|
{
|
|
ASSERT( m_pDocument->IsKindOf( RUNTIME_CLASS( CPBDoc ) ) );
|
|
return (CPBDoc*)m_pDocument;
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
/***************************************************************************/
|
|
// CPBView message handlers
|
|
int CPBView::OnCreate( LPCREATESTRUCT lpCreateStruct )
|
|
{
|
|
if (CView::OnCreate( lpCreateStruct ) == -1)
|
|
return -1;
|
|
|
|
#ifdef USE_MIRRORING
|
|
//
|
|
// Disable RTL mirroring on client drawing area. [samera]
|
|
//
|
|
if (lpCreateStruct->dwExStyle & WS_EX_LAYOUTRTL)
|
|
{
|
|
SetWindowLong( GetSafeHwnd(), GWL_EXSTYLE, lpCreateStruct->dwExStyle & ~WS_EX_LAYOUTRTL );
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnShowWindow( BOOL bShow, UINT nStatus )
|
|
{
|
|
if (theApp.m_bPrintOnly)
|
|
return;
|
|
|
|
CView::OnShowWindow( bShow, nStatus );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnDestroy()
|
|
{
|
|
// reset the toolbar
|
|
if (g_pImgToolWnd && g_pImgToolWnd->m_hWnd &&
|
|
IsWindow(g_pImgToolWnd->m_hWnd) )
|
|
{
|
|
g_pImgToolWnd->SelectTool( IDMB_ARROW );
|
|
g_pImgToolWnd->InvalidateOptions();
|
|
}
|
|
|
|
DestroyThumbNailView();
|
|
|
|
if (m_pImgWnd)
|
|
{
|
|
if ( ::IsWindow(m_pImgWnd->m_hWnd) )
|
|
m_pImgWnd->DestroyWindow();
|
|
|
|
delete m_pImgWnd;
|
|
m_pImgWnd = NULL;
|
|
}
|
|
|
|
CView::OnDestroy();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnInitialUpdate( void )
|
|
{
|
|
CPBDoc* pDoc = GetDocument();
|
|
|
|
if (SetObject())
|
|
{
|
|
if (theApp.m_bPrintOnly)
|
|
{
|
|
if (pDoc->m_bObjectLoaded)
|
|
{
|
|
OnFilePrint();
|
|
|
|
GetParentFrame()->PostMessage( WM_CLOSE );
|
|
return;
|
|
}
|
|
theApp.m_bPrintOnly = FALSE;
|
|
}
|
|
|
|
theUndo.SetMaxLevels( 3 );
|
|
|
|
SetTools();
|
|
}
|
|
else
|
|
{
|
|
if (pDoc->m_pBitmapObjNew != NULL)
|
|
{
|
|
delete pDoc->m_pBitmapObjNew;
|
|
pDoc->m_pBitmapObjNew = NULL;
|
|
}
|
|
|
|
TRACE( TEXT("OnInitialUpdate SetObject Failed!\n") );
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnActivateView( BOOL bActivate, CView* pActivateView,
|
|
CView* pDeactiveView )
|
|
{
|
|
CView::OnActivateView( bActivate, pActivateView, pDeactiveView );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL CPBView::OnCmdMsg( UINT nID, int nCode, void* pExtra,
|
|
AFX_CMDHANDLERINFO* pHandlerInfo )
|
|
{
|
|
if (nCode == CN_COMMAND)
|
|
{
|
|
if (m_pImgWnd
|
|
&& m_pImgWnd->OnCmdMsg( nID, nCode, pExtra, pHandlerInfo ))
|
|
return TRUE;
|
|
}
|
|
|
|
return CView::OnCmdMsg( nID, nCode, pExtra, pHandlerInfo );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
|
|
void CPBView::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
CView::OnSize( nType, cx, cy );
|
|
|
|
// TODO: Add your message handler code here
|
|
if (m_pImgWnd)
|
|
m_pImgWnd->MoveWindow( 0, 0, cx, cy );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL CPBView::SetObject()
|
|
{
|
|
CPBDoc* pDoc = GetDocument();
|
|
|
|
ASSERT( pDoc );
|
|
ASSERT( pDoc->m_pBitmapObjNew );
|
|
|
|
if (! pDoc || ! pDoc->m_pBitmapObjNew)
|
|
return FALSE;
|
|
|
|
CBitmapObj* pBitmapObj = pDoc->m_pBitmapObjNew;
|
|
|
|
// see if a bad file was loaded, but not an empty file, which is OK
|
|
if (! pDoc->m_bObjectLoaded
|
|
&& ! pBitmapObj->m_bTempName
|
|
&& pBitmapObj->m_hThing
|
|
&& pBitmapObj->m_lMemSize)
|
|
{
|
|
delete pBitmapObj;
|
|
pBitmapObj = NULL;
|
|
|
|
CString strDocName;
|
|
CString strFilterExt;
|
|
|
|
if (! pDoc->GetDocTemplate()->GetDocString( strDocName, CDocTemplate::docName )
|
|
|| strDocName.IsEmpty())
|
|
// use generic 'untitled'
|
|
VERIFY( strDocName.LoadString( AFX_IDS_UNTITLED ) );
|
|
|
|
if (! pDoc->GetDocTemplate()->GetDocString( strFilterExt, CDocTemplate::filterExt )
|
|
|| strFilterExt.IsEmpty())
|
|
pDoc->SetPathName( strDocName );
|
|
else
|
|
pDoc->SetPathName( strDocName + strFilterExt );
|
|
|
|
// do settitle after setpathname.
|
|
pDoc->SetTitle( strDocName );
|
|
|
|
pDoc->m_sName.Empty();
|
|
pDoc->m_bNewDoc = TRUE;
|
|
|
|
if (! pDoc->CreateNewDocument())
|
|
return FALSE;
|
|
|
|
pBitmapObj = pDoc->m_pBitmapObjNew;
|
|
}
|
|
|
|
if (! pBitmapObj->m_pImg
|
|
&& ! pBitmapObj->CreateImg())
|
|
return FALSE;
|
|
|
|
if (pBitmapObj->m_pImg->cxWidth < 1
|
|
|| pBitmapObj->m_pImg->cyHeight < 1)
|
|
{
|
|
CmpMessageBox( IDS_ERROR_BITMAPSIZE, AFX_IDS_APP_TITLE, MB_OK | MB_ICONEXCLAMATION );
|
|
return FALSE;
|
|
}
|
|
|
|
CleanupImgUndo();
|
|
CleanupImgRubber();
|
|
|
|
if (! SetView( pBitmapObj ))
|
|
return FALSE;
|
|
|
|
if (pDoc->m_pBitmapObj)
|
|
{
|
|
delete pDoc->m_pBitmapObj;
|
|
pDoc->m_pBitmapObj = NULL;
|
|
}
|
|
|
|
pDoc->m_pBitmapObj = pBitmapObj;
|
|
pDoc->m_pBitmapObjNew = NULL;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL CPBView::SetView( CBitmapObj* pBitmapObj )
|
|
{
|
|
IMG* pImg = pBitmapObj->m_pImg;
|
|
|
|
ASSERT( pImg );
|
|
|
|
CImgWnd* pImgWnd = new CImgWnd( pImg );
|
|
|
|
if (pImgWnd == NULL)
|
|
{
|
|
theApp.SetMemoryEmergency();
|
|
|
|
TRACE( TEXT("Create CImgWnd faild\n") );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
RECT rectPos;
|
|
|
|
GetClientRect( &rectPos );
|
|
|
|
if (! pImgWnd->Create( WS_CHILD | WS_VISIBLE, rectPos, this ))
|
|
{
|
|
TRACE( TEXT("Create img wnd failed\n") );
|
|
return FALSE;
|
|
}
|
|
|
|
if (m_pImgWnd)
|
|
{
|
|
if ( ::IsWindow( m_pImgWnd->m_hWnd) )
|
|
m_pImgWnd->DestroyWindow();
|
|
delete m_pImgWnd;
|
|
m_pImgWnd = NULL;
|
|
}
|
|
|
|
m_pImgWnd = pImgWnd;
|
|
|
|
if (m_pwndThumbNailView != NULL)
|
|
{
|
|
m_pImgWnd->SetThumbnailView( m_pwndThumbNailView );
|
|
m_pwndThumbNailView->UpdateThumbNailView();
|
|
}
|
|
|
|
m_pImgWnd->SetZoom( 1 );
|
|
// m_pImgWnd->SetFocus(); // Commented out to prevent focus problems w/OLE
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
int CPBView::SetTools()
|
|
{
|
|
CFrameWnd* pOwnerWindow = GetParentFrame();
|
|
CFrameWnd* pParentWindow = pOwnerWindow;
|
|
BOOL bRestoreState = FALSE;
|
|
|
|
ASSERT( pOwnerWindow != NULL );
|
|
|
|
if (! theApp.m_bLinked && theApp.m_pwndInPlaceFrame != NULL)
|
|
{
|
|
pOwnerWindow = theApp.m_pwndInPlaceFrame;
|
|
|
|
if (theApp.m_hwndInPlaceApp != NULL)
|
|
pParentWindow = (CFrameWnd*)CFrameWnd::FromHandle( theApp.m_hwndInPlaceApp );
|
|
}
|
|
|
|
|
|
ASSERT(g_pStatBarWnd);
|
|
ASSERT(g_pImgToolWnd);
|
|
ASSERT(g_pImgColorsWnd);
|
|
|
|
// Create the status bar
|
|
if ( !g_pStatBarWnd->m_hWnd )
|
|
{
|
|
if ( g_pStatBarWnd->Create(pParentWindow) )
|
|
{
|
|
if (theApp.m_fntStatus.m_hObject != NULL)
|
|
g_pStatBarWnd->SetFont( &theApp.m_fntStatus, FALSE );
|
|
g_pStatBarWnd->SetOwner(pOwnerWindow);
|
|
ShowStatusBar(TRUE);
|
|
|
|
bRestoreState = TRUE;
|
|
}
|
|
else
|
|
{
|
|
TRACE0("Failed to create status bar\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
pParentWindow->EnableDocking(CBRS_ALIGN_ANY);
|
|
|
|
// Create and dock the tool bar
|
|
if ( !g_pImgToolWnd->m_hWnd || !IsWindow(g_pImgToolWnd->m_hWnd) )
|
|
{
|
|
CString strToolWnd;
|
|
strToolWnd.LoadString(IDS_PAINT_TOOL);
|
|
if ( g_pImgToolWnd->Create( strToolWnd,
|
|
WS_CHILD|WS_VISIBLE|CBRS_LEFT,
|
|
CRect(0, 0, 0, 0),
|
|
CPoint(25, 25),
|
|
2,
|
|
pParentWindow ) )
|
|
{
|
|
g_pImgToolWnd->SetOwner(pOwnerWindow);
|
|
g_pImgToolWnd->EnableDocking(CBRS_ALIGN_LEFT|CBRS_ALIGN_RIGHT);
|
|
pParentWindow->DockControlBar(g_pImgToolWnd,
|
|
AFX_IDW_DOCKBAR_LEFT);
|
|
|
|
bRestoreState = TRUE;
|
|
}
|
|
else
|
|
{
|
|
TRACE0("Failed to create toolbar\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Create and dock the color bar
|
|
if ( !g_pImgColorsWnd->m_hWnd || !IsWindow(g_pImgColorsWnd->m_hWnd) )
|
|
{
|
|
CString strColorsWnd;
|
|
strColorsWnd.LoadString(IDS_COLORS);
|
|
if ( g_pImgColorsWnd->Create(strColorsWnd,
|
|
WS_CHILD|WS_VISIBLE|CBRS_BOTTOM,
|
|
pParentWindow) )
|
|
{
|
|
g_pImgColorsWnd->SetOwner(pOwnerWindow);
|
|
g_pImgColorsWnd->EnableDocking(CBRS_ALIGN_BOTTOM|CBRS_ALIGN_TOP);
|
|
pParentWindow->DockControlBar(g_pImgColorsWnd,
|
|
AFX_IDW_DOCKBAR_BOTTOM);
|
|
|
|
bRestoreState = TRUE;
|
|
}
|
|
else
|
|
{
|
|
TRACE0("Failed to create colorbar\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if ( bRestoreState && !theApp.m_bLinked && !theApp.m_bEmbedded && !theApp.m_pwndInPlaceFrame )
|
|
pOwnerWindow->LoadBarState(TEXT("General")); // Dangerous in-place!
|
|
|
|
pOwnerWindow->DelayRecalcLayout( TRUE );
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************/
|
|
BOOL CPBView::DestroyThumbNailView()
|
|
{
|
|
BOOL bResult = FALSE;
|
|
BOOL bOriginalSetting = theApp.m_bShowThumbnail;
|
|
|
|
theApp.m_bShowThumbnail = FALSE;
|
|
|
|
if (m_pwndThumbNailFloat != NULL)
|
|
{
|
|
if ( ::IsWindow(m_pwndThumbNailFloat->m_hWnd) )
|
|
m_pwndThumbNailFloat->DestroyWindow();
|
|
delete m_pwndThumbNailFloat;
|
|
m_pwndThumbNailFloat = NULL;
|
|
bResult = TRUE;
|
|
}
|
|
|
|
|
|
theApp.m_bShowThumbnail = bOriginalSetting;
|
|
m_pwndThumbNailView = NULL;
|
|
|
|
if (m_pImgWnd)
|
|
m_pImgWnd->SetThumbnailView( NULL );
|
|
|
|
return bResult;
|
|
}
|
|
|
|
BOOL CPBView::CreateThumbNailView()
|
|
{
|
|
if (m_pImgWnd == NULL)
|
|
return FALSE;
|
|
|
|
DestroyThumbNailView();
|
|
|
|
|
|
m_pwndThumbNailFloat = new CFloatThumbNailView( m_pImgWnd );
|
|
|
|
if (m_pwndThumbNailFloat != NULL)
|
|
{
|
|
if (m_pwndThumbNailFloat->Create( this ))
|
|
m_pwndThumbNailView = m_pwndThumbNailFloat->GetThumbNailView();
|
|
|
|
if (m_pwndThumbNailView)
|
|
{
|
|
m_pImgWnd->SetThumbnailView( m_pwndThumbNailView );
|
|
m_pwndThumbNailFloat->ShowWindow( SW_SHOWNOACTIVATE );
|
|
}
|
|
else
|
|
{
|
|
delete m_pwndThumbNailFloat;
|
|
m_pwndThumbNailFloat = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
if (m_pwndThumbNailView == NULL)
|
|
{
|
|
theApp.m_bShowThumbnail = FALSE;
|
|
theApp.SetMemoryEmergency();
|
|
|
|
TRACE( TEXT("Create CThumbNailView failed\n") );
|
|
return FALSE;
|
|
}
|
|
|
|
m_pwndThumbNailView->ShowWindow( SW_SHOWNOACTIVATE );
|
|
m_pwndThumbNailView->UpdateWindow();
|
|
UpdateWindow();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::ToggleThumbNailVisibility( void )
|
|
{
|
|
theApp.m_bShowThumbnail = !IsThumbNailVisible();
|
|
|
|
if ( theApp.m_bShowThumbnail )
|
|
ShowThumbNailView();
|
|
else if (m_pwndThumbNailView)
|
|
HideThumbNailView();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::HideThumbNailView(void)
|
|
{
|
|
if (IsThumbNailVisible())
|
|
{
|
|
if (m_pwndThumbNailFloat)
|
|
m_pwndThumbNailFloat->ShowWindow( SW_HIDE );
|
|
|
|
|
|
theApp.m_bShowThumbnail = FALSE;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::ShowThumbNailView(void)
|
|
{
|
|
if ( theApp.m_bShowThumbnail
|
|
&& !IsThumbNailVisible() )
|
|
{
|
|
if ( m_pwndThumbNailView )
|
|
{
|
|
if (m_pwndThumbNailFloat)
|
|
m_pwndThumbNailFloat->ShowWindow( SW_SHOWNOACTIVATE );
|
|
|
|
}
|
|
else
|
|
CreateThumbNailView();
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL CPBView::IsThumbNailVisible(void)
|
|
{
|
|
BOOL bVisible = FALSE;
|
|
|
|
|
|
if (m_pwndThumbNailFloat != NULL)
|
|
bVisible = m_pwndThumbNailFloat->IsWindowVisible();
|
|
|
|
return bVisible;
|
|
}
|
|
|
|
|
|
/***************************************************************************/
|
|
|
|
CPoint CPBView::GetDockedPos( DOCKERS tool, CSize& sizeTool )
|
|
{
|
|
CPoint pt;
|
|
CRect rectClient;
|
|
CRect rectView;
|
|
CFrameWnd* pFrame = GetParentFrame();
|
|
|
|
pFrame->GetClientRect( &rectClient );
|
|
pFrame->NegotiateBorderSpace( CFrameWnd::borderGet, &rectView );
|
|
|
|
switch (tool)
|
|
{
|
|
case toolbox:
|
|
ASSERT(0);
|
|
break;
|
|
|
|
case colorbox:
|
|
ASSERT(0);
|
|
break;
|
|
|
|
}
|
|
pt = rectView.TopLeft();
|
|
pFrame->ClientToScreen( &pt );
|
|
return pt;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::GetFloatPos( DOCKERS tool, CRect& rectPos )
|
|
{
|
|
// removed docked thumbnail code
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::SetFloatPos( DOCKERS tool, CRect& rectPos )
|
|
{
|
|
//removed docked thumbnail code
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnViewThumbnail()
|
|
{
|
|
ToggleThumbNailVisibility();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateViewThumbnail(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd != NULL
|
|
&& m_pImgWnd->GetZoom() > 1)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
pCmdUI->SetCheck( theApp.m_bShowThumbnail );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEditUndo()
|
|
{
|
|
if (!TextToolProcessed( ID_EDIT_UNDO ))
|
|
{
|
|
CancelToolMode(FALSE);
|
|
|
|
CommitSelection(TRUE);
|
|
|
|
theUndo.DoUndo();
|
|
DirtyImg (m_pImgWnd->m_pImg);
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEditRedo()
|
|
{
|
|
CancelToolMode(FALSE);
|
|
|
|
theUndo.DoRedo();
|
|
DirtyImg (m_pImgWnd->m_pImg);
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEditCut()
|
|
{
|
|
m_pImgWnd->CmdCut();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEditClear()
|
|
{
|
|
m_pImgWnd->CmdClear();
|
|
}
|
|
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEditCopy()
|
|
{
|
|
m_pImgWnd->CmdCopy();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEditPaste()
|
|
{
|
|
m_pImgWnd->CmdPaste();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
|
|
void CPBView::OnUpdateEditUndo(CCmdUI* pCmdUI)
|
|
{
|
|
// the text tool has no idea if it can undo and neither do we
|
|
pCmdUI->Enable(IsUserEditingText() || theUndo.CanUndo());
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateEditRedo(CCmdUI* pCmdUI)
|
|
{
|
|
// the text tool does not have a redo stack
|
|
pCmdUI->Enable(!IsUserEditingText() && theUndo.CanRedo());
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateEditSelection(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd != NULL)
|
|
{
|
|
bEnable = m_pImgWnd->IsSelectionAvailable();
|
|
}
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateEditClearSel(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd != NULL)
|
|
bEnable = m_pImgWnd->IsSelectionAvailable();
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateEditPaste(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd != NULL)
|
|
{
|
|
bEnable = m_pImgWnd->IsPasteAvailable();
|
|
}
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnViewGrid()
|
|
{
|
|
m_pImgWnd->CmdShowGrid();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnViewZoom100()
|
|
{
|
|
if (m_pImgWnd->GetZoom() != 1)
|
|
{
|
|
m_pImgWnd->SetZoom ( 1 );
|
|
m_pImgWnd->CheckScrollBars();
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnViewZoom400()
|
|
{
|
|
if (m_pImgWnd->GetZoom() != 4)
|
|
{
|
|
m_pImgWnd->SetZoom ( 4 );
|
|
m_pImgWnd->CheckScrollBars();
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnViewZoom()
|
|
{
|
|
CZoomViewDlg dlg;
|
|
|
|
dlg.m_nCurrent = m_pImgWnd->GetZoom();
|
|
|
|
if (dlg.DoModal() != IDOK)
|
|
return;
|
|
|
|
m_pImgWnd->SetZoom( dlg.m_nCurrent );
|
|
m_pImgWnd->CheckScrollBars();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateViewZoom100(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd)
|
|
bEnable = (m_pImgWnd->GetZoom() != 1);
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateViewZoom400(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd)
|
|
bEnable = (m_pImgWnd->GetZoom() != 4);
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateViewGrid(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bCheck = FALSE;
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd)
|
|
{
|
|
bEnable = (m_pImgWnd->GetZoom() > 2);
|
|
bCheck = m_pImgWnd->IsGridVisible();
|
|
}
|
|
pCmdUI->Enable ( bEnable );
|
|
pCmdUI->SetCheck( bCheck );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnImageInvertColors()
|
|
{
|
|
CancelToolMode(TRUE);
|
|
|
|
m_pImgWnd->CmdInvertColors();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
// Don't show the Invert Colors menu item if we're using a palette
|
|
void CPBView::OnUpdateImageInvertColors(CCmdUI* pCmdUI)
|
|
{
|
|
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd)
|
|
{
|
|
bEnable = (!theApp.m_bPaletted);
|
|
}
|
|
pCmdUI->Enable ( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnTglopaque()
|
|
{
|
|
m_pImgWnd->CmdTglOpaque();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateTglopaque(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( m_pImgWnd != NULL );
|
|
pCmdUI->SetCheck( theImgBrush.m_bOpaque );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnImageAttributes()
|
|
{
|
|
CancelToolMode(FALSE);
|
|
|
|
CPBDoc* pDoc = GetDocument();
|
|
|
|
ASSERT( pDoc );
|
|
ASSERT( m_pImgWnd );
|
|
|
|
CBitmapObj* pBitmapRes = pDoc->m_pBitmapObj;
|
|
|
|
CImageAttr dlg;
|
|
|
|
BOOL bMono = (pBitmapRes->m_pImg->cPlanes == 1
|
|
&& pBitmapRes->m_pImg->cBitCount == 1);
|
|
|
|
dlg.m_bMonochrome = bMono;
|
|
dlg.SetWidthHeight( pBitmapRes->m_pImg->cxWidth,
|
|
pBitmapRes->m_pImg->cyHeight,
|
|
pBitmapRes->m_pImg->cXPelsPerMeter,
|
|
pBitmapRes->m_pImg->cYPelsPerMeter);
|
|
|
|
if (dlg.DoModal() != IDOK)
|
|
return;
|
|
|
|
CSize size = dlg.GetWidthHeight();
|
|
|
|
if (size.cx != pBitmapRes->m_pImg->cxWidth
|
|
|| size.cy != pBitmapRes->m_pImg->cyHeight)
|
|
{
|
|
theUndo.BeginUndo( TEXT("Property Edit") );
|
|
|
|
BOOL bSuccess = pBitmapRes->SetSizeProp( P_Size, size );
|
|
|
|
theUndo.EndUndo();
|
|
|
|
if (bSuccess)
|
|
theApp.m_sizeBitmap = size;
|
|
}
|
|
|
|
if (dlg.m_bMonochrome != bMono
|
|
&& (!dlg.m_bMonochrome
|
|
|| AfxMessageBox(IDS_WARNING_MONO, MB_YESNO|MB_ICONEXCLAMATION)==IDYES))
|
|
{
|
|
theUndo.BeginUndo( TEXT("Property Edit") );
|
|
|
|
pBitmapRes->SetIntProp( P_Colors, dlg.m_bMonochrome );
|
|
|
|
theUndo.EndUndo();
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnImageClearImage()
|
|
{
|
|
CancelToolMode(FALSE);
|
|
|
|
m_pImgWnd->CmdClear();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnFilePrint()
|
|
{
|
|
CancelToolMode(FALSE);
|
|
|
|
CView::OnFilePrint();
|
|
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnFilePrintPreview()
|
|
{
|
|
CancelToolMode(FALSE);
|
|
|
|
CView::OnFilePrintPreview();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateImageClearImage( CCmdUI* pCmdUI )
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd)
|
|
bEnable = (CImgTool::GetCurrentID() != IDMX_TEXTTOOL
|
|
&& ! m_pImgWnd->IsSelectionAvailable() );
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnSel2bsh()
|
|
{
|
|
m_pImgWnd->CmdSel2Bsh();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnLargerbrush()
|
|
{
|
|
m_pImgWnd->CmdLargerBrush();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnSmallerbrush()
|
|
{
|
|
m_pImgWnd->CmdSmallerBrush();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnImageFlipRotate()
|
|
{
|
|
CancelToolMode(TRUE);
|
|
|
|
CFlipRotateDlg dlg;
|
|
|
|
if (dlg.DoModal() != IDOK)
|
|
return;
|
|
|
|
if (dlg.m_bAngle)
|
|
{
|
|
switch (dlg.m_nAngle)
|
|
{
|
|
case 90:
|
|
m_pImgWnd->CmdRot90();
|
|
break;
|
|
|
|
case 180:
|
|
theUndo.BeginUndo( TEXT("Rotate 180") );
|
|
|
|
m_pImgWnd->CmdFlipBshH();
|
|
m_pImgWnd->CmdFlipBshV();
|
|
|
|
theUndo.EndUndo();
|
|
break;
|
|
|
|
case 270:
|
|
theUndo.BeginUndo( TEXT("Rotate 270") );
|
|
|
|
m_pImgWnd->CmdRot90();
|
|
m_pImgWnd->CmdFlipBshH();
|
|
m_pImgWnd->CmdFlipBshV();
|
|
|
|
theUndo.EndUndo();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
if (dlg.m_bHorz)
|
|
m_pImgWnd->CmdFlipBshH();
|
|
else
|
|
m_pImgWnd->CmdFlipBshV();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateImageFlipRotate(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( m_pImgWnd != NULL );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEditcolors()
|
|
{
|
|
g_pColors->CmdEditColor();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateEditcolors(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( g_pColors != NULL );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
#if 0
|
|
void CPBView::OnLoadcolors()
|
|
{
|
|
CancelToolMode(FALSE);
|
|
|
|
g_pColors->CmdLoadColors();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateLoadcolors(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (g_pColors && m_pImgWnd && m_pImgWnd->m_pImg &&
|
|
m_pImgWnd->m_pImg->m_pBitmapObj)
|
|
{
|
|
// not allowed except on 24 bit images
|
|
bEnable = ( m_pImgWnd->m_pImg->m_pBitmapObj->m_nColors == 3 );
|
|
}
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnSavecolors()
|
|
{
|
|
g_pColors->CmdSaveColors();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateSavecolors(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( g_pColors != NULL );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
#endif
|
|
void CPBView::OnEditSelectAll()
|
|
{
|
|
if (m_pImgWnd)
|
|
{
|
|
if (!TextToolProcessed( ID_EDIT_SELECT_ALL ))
|
|
{
|
|
IMG *img = m_pImgWnd? m_pImgWnd->GetImg() : NULL;
|
|
|
|
if (img)
|
|
{
|
|
CImgTool::Select(IDMB_PICKTOOL);
|
|
m_pImgWnd->MakeBrush( img->hDC,
|
|
CRect( 0, 0, img->cxWidth, img->cyHeight ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEditPasteFrom()
|
|
{
|
|
CBitmapObj *pResObject = new CBitmapObj();
|
|
|
|
ASSERT(pResObject != NULL);
|
|
|
|
if (pResObject != NULL)
|
|
{
|
|
ASSERT( m_pImgWnd != NULL );
|
|
|
|
pResObject->MakeEmpty();
|
|
|
|
CString newName;
|
|
int iColor = 0;
|
|
|
|
if (theApp.DoPromptFileName( newName, IDS_EDIT_PASTE_FROM,
|
|
OFN_PATHMUSTEXIST, TRUE, iColor, FALSE ))
|
|
{
|
|
if (pResObject->Import( newName ))
|
|
{
|
|
LPSTR lpDib = (LPSTR) GlobalLock(pResObject->m_hThing);
|
|
m_pImgWnd->PasteImageFile( lpDib );
|
|
GlobalUnlock(pResObject->m_hThing);
|
|
}
|
|
}
|
|
|
|
pResObject->m_pImg = NULL;
|
|
delete pResObject;
|
|
pResObject = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL FillBitmapObj(CImgWnd* pImgWnd, CBitmapObj* pResObject, IMG* pImgStruct,
|
|
int iColor)
|
|
{
|
|
ASSERT(pImgWnd != NULL);
|
|
|
|
pResObject->MakeEmpty();
|
|
|
|
if (pImgWnd->m_pImg == NULL
|
|
|| pImgWnd->m_pImg->m_pBitmapObj == NULL
|
|
|| pImgWnd->m_pImg->m_pBitmapObj->m_pImg == NULL)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
if (iColor < 0)
|
|
{
|
|
iColor = pImgWnd->m_pImg->m_pBitmapObj->m_nColors;
|
|
}
|
|
|
|
if (theImgBrush.m_bFirstDrag)
|
|
{
|
|
PickupSelection();
|
|
}
|
|
|
|
*pImgStruct = *theImgBrush.m_pImg;
|
|
|
|
pImgStruct->hDC = theImgBrush.m_dc.GetSafeHdc();
|
|
pImgStruct->hBitmap = (HBITMAP)theImgBrush.m_bitmap.GetSafeHandle();
|
|
pImgStruct->hBitmapOld = theImgBrush.m_hbmOld;
|
|
pImgStruct->bDirty = TRUE;
|
|
pImgStruct->m_pPalette = theApp.m_pPalette;
|
|
pImgStruct->cxWidth = theImgBrush.m_size.cx;
|
|
pImgStruct->cyHeight = theImgBrush.m_size.cy;
|
|
|
|
if (iColor < 4 && iColor >= 0)
|
|
{
|
|
pResObject->m_nSaveColors = iColor;
|
|
}
|
|
|
|
#ifdef PCX_SUPPORT
|
|
pResObject->m_bPCX = (iColor == 4);
|
|
#endif
|
|
#ifdef ICO_SUPPORT
|
|
pResObject->m_bSaveIcon = (iColor == 5);
|
|
#endif
|
|
pResObject->m_nWidth = pImgStruct->cxWidth;
|
|
pResObject->m_nHeight = pImgStruct->cyHeight;
|
|
pResObject->m_nColors = pImgWnd->m_pImg->m_pBitmapObj->m_nColors;
|
|
pResObject->m_bCompressed = pImgWnd->m_pImg->m_pBitmapObj->m_bCompressed;
|
|
|
|
pResObject->m_pImg = pImgStruct;
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
void CPBView::OnEditCopyTo()
|
|
{
|
|
CString newName;
|
|
int iColor = m_pImgWnd->m_pImg->m_pBitmapObj->m_nColors;
|
|
|
|
if (theApp.DoPromptFileName( newName, IDS_EDIT_COPY_TO,
|
|
OFN_HIDEREADONLY | OFN_PATHMUSTEXIST, FALSE, iColor, TRUE ))
|
|
{
|
|
BeginWaitCursor();
|
|
|
|
CBitmapObj cResObject;
|
|
|
|
IMG imgStruct;
|
|
|
|
if (!FillBitmapObj(m_pImgWnd, &cResObject, &imgStruct, iColor))
|
|
{
|
|
// FEATURE: Need an error message
|
|
// Actually, can this ever happen?
|
|
return;
|
|
}
|
|
|
|
cResObject.SaveResource( FALSE );
|
|
cResObject.Export( newName );
|
|
|
|
EndWaitCursor();
|
|
|
|
// Don't delete this on destructor
|
|
cResObject.m_pImg = NULL;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateEditCopyTo(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (CImgTool::GetCurrentID() == IDMB_PICKTOOL
|
|
|| CImgTool::GetCurrentID() == IDMB_PICKRGNTOOL)
|
|
{
|
|
ASSERT( m_pImgWnd != NULL );
|
|
|
|
if (m_pImgWnd != NULL)
|
|
{
|
|
if (m_pImgWnd->m_pImg != NULL)
|
|
{
|
|
if (m_pImgWnd->m_pImg == theImgBrush.m_pImg)
|
|
{
|
|
bEnable = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnImageStretchSkew()
|
|
{
|
|
CancelToolMode(TRUE);
|
|
|
|
CStretchSkewDlg dlg;
|
|
|
|
if (dlg.DoModal() != IDOK)
|
|
return;
|
|
|
|
int iStretchHorz = dlg.GetStretchHorz();
|
|
int iStretchVert = dlg.GetStretchVert();
|
|
|
|
if (iStretchVert
|
|
|| iStretchHorz)
|
|
{
|
|
CPBDoc* pDoc = GetDocument();
|
|
|
|
ASSERT( pDoc );
|
|
|
|
int iWidthImg = pDoc->m_pBitmapObj->m_pImg->cxWidth;
|
|
int iHeightImg = pDoc->m_pBitmapObj->m_pImg->cyHeight;
|
|
|
|
if (theImgBrush.m_pImg == NULL)
|
|
{
|
|
int lX = iWidthImg + (iWidthImg * iStretchHorz) / 100;
|
|
int lY = iHeightImg + (iHeightImg * iStretchVert) / 100;
|
|
|
|
CBitmap bmWork;
|
|
CDC dcWork;
|
|
CDC* pdcImg = CDC::FromHandle( pDoc->m_pBitmapObj->m_pImg->hDC );
|
|
CSize sizeBMP( (UINT)lX, (UINT)lY );
|
|
CRect rect( 0, 0, lX, lY );
|
|
|
|
if (! dcWork.CreateCompatibleDC ( pdcImg )
|
|
|| ! bmWork.CreateCompatibleBitmap( pdcImg, iWidthImg, iHeightImg ))
|
|
{
|
|
theApp.SetGdiEmergency( TRUE );
|
|
return;
|
|
}
|
|
|
|
CBitmap* pbmOld = dcWork.SelectObject( &bmWork );
|
|
CPalette* ppalOld = m_pImgWnd->SetImgPalette( &dcWork, FALSE );
|
|
|
|
BeginWaitCursor();
|
|
|
|
dcWork.BitBlt( 0, 0, iWidthImg, iHeightImg, pdcImg, 0, 0, SRCCOPY );
|
|
|
|
theUndo.BeginUndo( TEXT("Property Edit") );
|
|
|
|
pDoc->m_pBitmapObj->SetSizeProp( P_Size, sizeBMP );
|
|
|
|
StretchCopy( pdcImg->m_hDC, 0, 0, lX, lY,
|
|
dcWork.m_hDC, 0, 0, iWidthImg, iHeightImg );
|
|
|
|
InvalImgRect ( m_pImgWnd->m_pImg, NULL );
|
|
CommitImgRect( m_pImgWnd->m_pImg, NULL );
|
|
theUndo.EndUndo();
|
|
DirtyImg(m_pImgWnd->m_pImg);
|
|
|
|
dcWork.SelectObject( pbmOld );
|
|
bmWork.DeleteObject();
|
|
|
|
if (ppalOld)
|
|
dcWork.SelectPalette( ppalOld, FALSE );
|
|
|
|
dcWork.DeleteDC();
|
|
|
|
theApp.m_sizeBitmap = sizeBMP;
|
|
|
|
EndWaitCursor();
|
|
}
|
|
else
|
|
{
|
|
CRect rect = theImgBrush.m_rcSelection;
|
|
long lX = theImgBrush.m_size.cx;
|
|
long lY = theImgBrush.m_size.cy;
|
|
|
|
lX += (lX * iStretchHorz) / 100;
|
|
lY += (lY * iStretchVert) / 100;
|
|
|
|
rect.right = rect.left + (UINT)lX;
|
|
rect.bottom = rect.top + (UINT)lY;
|
|
|
|
// If the image is a bitmap and the bitmap in the clipboard is larger,
|
|
// then give the suer the option2 of growing the image...
|
|
// if (lX > iWidthImg || lY > iHeightImg)
|
|
// {
|
|
// switch (AfxMessageBox( IDS_ENLAGEBITMAPFORSTRETCH,
|
|
// MB_YESNOCANCEL | MB_ICONQUESTION ))
|
|
// {
|
|
// default:
|
|
// return;
|
|
// break;
|
|
|
|
// case IDYES:
|
|
// {
|
|
// CSize size( max( lX, iWidthImg ),
|
|
// max( lY, iHeightImg ) );
|
|
|
|
// theUndo.BeginUndo( "Resize Bitmap" );
|
|
// VERIFY( pDoc->m_pBitmapObj->SetSizeProp( P_Size, size ) );
|
|
|
|
// theUndo.EndUndo();
|
|
// }
|
|
// break;
|
|
|
|
// case IDNO:
|
|
// break;
|
|
// }
|
|
// }
|
|
|
|
m_pImgWnd->PrepareForBrushChange();
|
|
|
|
HideBrush();
|
|
|
|
theImgBrush.SetSize( CSize( (UINT)lX, (UINT)lY ) );
|
|
|
|
SetCombineMode( combineColor );
|
|
|
|
InvalImgRect( theImgBrush.m_pImg, NULL ); // draw selection tracker
|
|
m_pImgWnd->MoveBrush( rect );
|
|
}
|
|
}
|
|
|
|
int wSkewHorz = (int)dlg.GetSkewHorz();
|
|
int wSkewVert = (int)dlg.GetSkewVert();
|
|
|
|
if (wSkewHorz)
|
|
m_pImgWnd->CmdSkewBrush( wSkewHorz, TRUE );
|
|
|
|
if (wSkewVert)
|
|
m_pImgWnd->CmdSkewBrush( wSkewVert, FALSE );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateImageStretchSkew(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( m_pImgWnd != NULL );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnViewViewPicture()
|
|
{
|
|
CPBDoc *pDoc;
|
|
CString strCaption;
|
|
|
|
ASSERT(! theApp.m_bEmbedded);
|
|
pDoc = GetDocument();
|
|
|
|
CFullScreenThumbNailView *pcThumbNailView = new CFullScreenThumbNailView( m_pImgWnd );
|
|
|
|
if ( pcThumbNailView == NULL
|
|
|| ! pcThumbNailView->Create((LPCTSTR)pDoc->GetPathName()))
|
|
{
|
|
theApp.SetMemoryEmergency();
|
|
|
|
TRACE( TEXT("Create CThumbNailView faild\n") );
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateViewViewPicture(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( m_pImgWnd != NULL );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnViewTextToolbar()
|
|
{
|
|
ASSERT( CImgTool::GetCurrentID() == IDMX_TEXTTOOL );
|
|
|
|
CTextTool* pTextTool = (CTextTool*)CImgTool::GetCurrent();
|
|
|
|
ASSERT( pTextTool->IsKindOf( RUNTIME_CLASS( CTextTool ) ) );
|
|
|
|
pTextTool->ToggleFontPalette();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateViewTextToolbar(CCmdUI* pCmdUI)
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (CImgTool::GetCurrentID() == IDMX_TEXTTOOL)
|
|
{
|
|
CTextTool* pTextTool = (CTextTool*)CImgTool::GetCurrent();
|
|
|
|
ASSERT( pTextTool );
|
|
ASSERT( pTextTool->IsKindOf( RUNTIME_CLASS( CTextTool ) ) );
|
|
|
|
if (pTextTool
|
|
&& pTextTool->IsSlectionVisible())
|
|
bEnable = TRUE;
|
|
}
|
|
|
|
pCmdUI->SetCheck( theApp.m_bShowTextToolbar );
|
|
pCmdUI->Enable ( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnFileSetaswallpaperT()
|
|
{
|
|
SetTheWallpaper( TRUE );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateFileSetaswallpaperT( CCmdUI* pCmdUI )
|
|
{
|
|
pCmdUI->Enable( CanSetWallpaper() );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnFileSetaswallpaperC()
|
|
{
|
|
SetTheWallpaper( FALSE );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateFileSetaswallpaperC(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable( CanSetWallpaper() );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL CPBView::CanSetWallpaper()
|
|
{
|
|
BOOL bEnable = FALSE;
|
|
|
|
if (m_pImgWnd != NULL)
|
|
{
|
|
CPBDoc* pDoc = GetDocument();
|
|
|
|
ASSERT( pDoc );
|
|
|
|
bEnable = (! pDoc->GetPathName().IsEmpty() || pDoc->IsModified());
|
|
|
|
// read the user policy key to see whether we should disable wallpaper setting
|
|
|
|
if (bEnable)
|
|
{
|
|
HKEY hKey = 0;
|
|
|
|
if (RegOpenKeyEx( HKEY_CURRENT_USER, REGSTR_PATH_POLICIES _T("\\ActiveDesktop"), 0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
|
|
{
|
|
BOOL bNoChangingWallpaper = FALSE;
|
|
DWORD cbData = sizeof(bNoChangingWallpaper);
|
|
|
|
if (RegQueryValueEx(hKey, _T("NoChangingWallpaper"), 0, 0, (PBYTE) &bNoChangingWallpaper, &cbData) == ERROR_SUCCESS)
|
|
{
|
|
bEnable = !bNoChangingWallpaper;
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
}
|
|
return bEnable;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::SetTheWallpaper( BOOL bTiled /* = FALSE */ )
|
|
{
|
|
CPBDoc* pDoc = GetDocument();
|
|
ASSERT( pDoc != NULL );
|
|
|
|
CString cStrFileName = pDoc->GetPathName();
|
|
|
|
BOOL bSetWallpaper = ! (cStrFileName.IsEmpty() || pDoc->IsModified() || pDoc->m_bNonBitmapFile);
|
|
|
|
if (! bSetWallpaper)
|
|
switch (AfxMessageBox( IDS_MUST_SAVE_WALLPAPER, MB_OKCANCEL | MB_ICONEXCLAMATION ))
|
|
{
|
|
case IDOK:
|
|
// If so, either Save or Update, as appropriate
|
|
bSetWallpaper = pDoc->SaveTheDocument();
|
|
cStrFileName = pDoc->GetPathName();
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
break;
|
|
|
|
default:
|
|
theApp.SetMemoryEmergency();
|
|
break;
|
|
}
|
|
|
|
if (bSetWallpaper)
|
|
{
|
|
DWORD dwDisp;
|
|
HKEY hKey = 0;
|
|
|
|
if (RegCreateKeyEx( HKEY_CURRENT_USER, TEXT("Control Panel\\Desktop"),
|
|
REG_OPTION_RESERVED, TEXT(""),
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS, NULL, &hKey, &dwDisp ) == ERROR_SUCCESS)
|
|
{
|
|
RegSetValueEx( hKey, TEXT("TileWallpaper"), 0, REG_SZ,
|
|
(BYTE *)(bTiled? TEXT("1"): TEXT("0")), 2*sizeof(TCHAR) );
|
|
RegCloseKey( hKey );
|
|
}
|
|
|
|
SystemParametersInfo( SPI_SETDESKWALLPAPER, bTiled? 1: 0,
|
|
(LPVOID)(cStrFileName.GetBuffer( cStrFileName.GetLength() )),
|
|
SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE );
|
|
|
|
cStrFileName.ReleaseBuffer();
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnPaletteChanged(CWnd* pFocusWnd)
|
|
{
|
|
// If this application did not change the palette, select
|
|
// and realize this application's palette
|
|
if ((pFocusWnd != m_pImgWnd)
|
|
&& (m_pImgWnd != NULL)
|
|
&& (m_pImgWnd->m_pImg != NULL))
|
|
{
|
|
if (theApp.m_pPalette)
|
|
{
|
|
// Redraw the entire client area
|
|
m_pImgWnd->InvalidateRect(NULL);
|
|
m_pImgWnd->UpdateWindow();
|
|
|
|
if (g_pImgColorsWnd && g_pImgColorsWnd->m_hWnd && IsWindow(g_pImgColorsWnd->m_hWnd))
|
|
{
|
|
InvalColorWnd();
|
|
// g_pImgColorsWnd->UpdateWindow();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
BOOL CPBView::OnQueryNewPalette()
|
|
{
|
|
HPALETTE hOldPal = NULL;
|
|
|
|
if (m_pImgWnd && ::IsWindow(m_pImgWnd->m_hWnd)
|
|
&& m_pImgWnd->m_pImg)
|
|
{
|
|
if (theApp.m_pPalette)
|
|
{
|
|
// Redraw the entire client area
|
|
m_pImgWnd->InvalidateRect(NULL);
|
|
m_pImgWnd->UpdateWindow();
|
|
|
|
if (g_pImgColorsWnd && g_pImgColorsWnd->m_hWnd && IsWindow(g_pImgColorsWnd->m_hWnd))
|
|
{
|
|
InvalColorWnd();
|
|
g_pImgColorsWnd->UpdateWindow();
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnUpdateImageAttributes( CCmdUI* pCmdUI )
|
|
{
|
|
BOOL bEnable = (m_pImgWnd != NULL);
|
|
|
|
pCmdUI->Enable( bEnable );
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEscape()
|
|
{
|
|
if (m_pImgWnd != NULL)
|
|
{
|
|
m_pImgWnd->CmdCancel();
|
|
}
|
|
|
|
OnCancelMode();
|
|
}
|
|
|
|
/***************************************************************************/
|
|
|
|
void CPBView::OnEscapeServer()
|
|
{
|
|
CImgTool* pImgTool = CImgTool::GetCurrent();
|
|
|
|
if (pImgTool->IsToolModal())
|
|
{
|
|
OnEscape();
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// Tell the OLE client (if there is one) we are all done
|
|
GetDocument()->OnDeactivateUI(FALSE);
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|