// 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 #ifdef USE_PRINTDLGEX #include #include #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); } } /***************************************************************************/