993 lines
31 KiB
C++
993 lines
31 KiB
C++
#include <meshwrp/imageview.hpp>
|
|
#include <meshwrp/resource.hpp>
|
|
#include <meshwrp/framedlg.hpp>
|
|
#include <meshwrp/factor.hpp>
|
|
#include <meshwrp/convex.hpp>
|
|
|
|
/*
|
|
#include <meshwrp/inifile.hpp>
|
|
#include <meshwrp/factor.hpp>
|
|
#include <meshwrp/frmdlg.hpp>
|
|
#include <meshwrp/paltdlg.hpp>
|
|
#include <meshwrp/resize.hpp>
|
|
#include <meshwrp/txlmtrx.hpp>
|
|
#include <meshwrp/shear.hpp>
|
|
#include <meshwrp/filehelp.hpp>
|
|
#include <meshwrp/main.hpp>
|
|
#include <meshwrp/segment.hpp>
|
|
#include <meshwrp/meshwrp.hpp>
|
|
#include <meshwrp/meshfrm.hpp>
|
|
#include <meshwrp/viewcntr.hpp>
|
|
#include <meshwrp/viewsel.hpp>
|
|
#include <meshwrp/dissolve.hpp>
|
|
#include <meshwrp/resource.hpp> */
|
|
|
|
//char ImageView::szClassName[]="GIFView";
|
|
//char ImageView::szMenuName[]="";
|
|
//HINSTANCE ImageView::smhInstance=0;
|
|
|
|
ImageView::ImageView()
|
|
/* : mhClientWindow(0), mhFrameWindow(0), mIsDestroyed(0),
|
|
mMaxColors(0), mWidth(0), mHeight(0), mhPalette(0),
|
|
mhGlobalInvert(0), mhGlobal(0), mhBMPGlobal(0), mpStatusBar(0),
|
|
mpProcessImage(0), mpBI(0), mhpImageInvert(0), mhpImage(0),
|
|
mhSystemMenu(0), mhFrameMenu(0), mhViewMenu(0), mpSpacial(0),
|
|
mpPerspectiveWarp(0), mlpClipboard(0), mlpToolBar(0), mlpGridMesh(0),
|
|
mlpConvexTransform(0), mToolbarVisibility(TRUE), mCurrentMeshFrames(DefaultFrames) */
|
|
: mCurrentMeshFrames(DefaultFrames)
|
|
{
|
|
mBkBrush.createHatchBrush(Brush::HDiagCross,RGBColor(128,128,128));
|
|
mPaintHandler.setCallback(this,&ImageView::paintHandler);
|
|
mCreateHandler.setCallback(this,&ImageView::createHandler);
|
|
mSizeHandler.setCallback(this,&ImageView::sizeHandler);
|
|
mVerticalScrollHandler.setCallback(this,&ImageView::verticalScrollHandler);
|
|
mHorizontalScrollHandler.setCallback(this,&ImageView::horizontalScrollHandler);
|
|
mEraseBackgroundHandler.setCallback(this,&ImageView::eraseBackgroundHandler);
|
|
|
|
|
|
installHandlers();
|
|
// mPathFileName[0]=0;
|
|
}
|
|
|
|
ImageView::ImageView(const ImageView &/*someImageView*/)
|
|
: mCurrentMeshFrames(DefaultFrames)
|
|
/*: mhClientWindow(0), mhFrameWindow(0), mIsDestroyed(0),
|
|
mMaxColors(0), mWidth(0), mHeight(0), mhPalette(0),
|
|
mhGlobalInvert(0), mhGlobal(0), mhBMPGlobal(0), mpStatusBar(0),
|
|
mpProcessImage(0), mpBI(0), mhpImageInvert(0), mhpImage(0),
|
|
mhSystemMenu(0), mhFrameMenu(0), mhViewMenu(0), mpSpacial(0),
|
|
mpPerspectiveWarp(0), mlpClipboard(0), mlpToolBar(0), mlpGridMesh(0),
|
|
mlpConvexTransform(0), mToolbarVisibility(TRUE), mCurrentMeshFrames(DefaultFrames) */
|
|
{
|
|
mBkBrush.createHatchBrush(Brush::HDiagCross,RGBColor(128,128,128));
|
|
mPaintHandler.setCallback(this,&ImageView::paintHandler);
|
|
mCreateHandler.setCallback(this,&ImageView::createHandler);
|
|
mSizeHandler.setCallback(this,&ImageView::sizeHandler);
|
|
mVerticalScrollHandler.setCallback(this,&ImageView::verticalScrollHandler);
|
|
mHorizontalScrollHandler.setCallback(this,&ImageView::horizontalScrollHandler);
|
|
mEraseBackgroundHandler.setCallback(this,&ImageView::eraseBackgroundHandler);
|
|
installHandlers();
|
|
}
|
|
|
|
ImageView::~ImageView()
|
|
{
|
|
removeHandlers();
|
|
/* if(mhPalette)::DeleteObject(mhPalette);
|
|
if(mhGlobalInvert)
|
|
{
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
::GlobalFree(mhGlobalInvert);
|
|
}
|
|
if(mhBMPGlobal)
|
|
{
|
|
::GlobalUnlock(mhBMPGlobal);
|
|
::GlobalFree(mhBMPGlobal);
|
|
}
|
|
if(mhViewMenu)::DestroyMenu(mhViewMenu);
|
|
if(!mIsDestroyed && GetHandle())
|
|
::SendMessage(mhClientWindow,WM_MDIDESTROY,(WPARAM)GetHandle(),0L);
|
|
if(mlpToolBar)delete mlpToolBar;
|
|
if(mlpGridMesh)delete mlpGridMesh; */
|
|
}
|
|
|
|
void ImageView::installHandlers()
|
|
{
|
|
insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
|
|
insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
|
|
insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
|
|
insertHandler(VectorHandler::VerticalScrollHandler,&mVerticalScrollHandler);
|
|
insertHandler(VectorHandler::HorizontalScrollHandler,&mHorizontalScrollHandler);
|
|
insertHandler(VectorHandler::EraseBackgroundHandler,&mHorizontalScrollHandler);
|
|
}
|
|
|
|
void ImageView::removeHandlers()
|
|
{
|
|
removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
|
|
removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
|
|
removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
|
|
removeHandler(VectorHandler::VerticalScrollHandler,&mVerticalScrollHandler);
|
|
removeHandler(VectorHandler::HorizontalScrollHandler,&mHorizontalScrollHandler);
|
|
removeHandler(VectorHandler::EraseBackgroundHandler,&mHorizontalScrollHandler);
|
|
}
|
|
|
|
CallbackData::ReturnType ImageView::createHandler(CallbackData &callbackData)
|
|
{
|
|
mScrollInfo.hwndOwner(*this);
|
|
return FALSE;
|
|
}
|
|
|
|
CallbackData::ReturnType ImageView::sizeHandler(CallbackData &callbackData)
|
|
{
|
|
mScrollInfo.handleSize(callbackData);
|
|
return FALSE;
|
|
}
|
|
|
|
CallbackData::ReturnType ImageView::horizontalScrollHandler(CallbackData &callbackData)
|
|
{
|
|
mScrollInfo.handleHorizontalScroll(callbackData);
|
|
return (CallbackData::ReturnType)FALSE;
|
|
}
|
|
|
|
CallbackData::ReturnType ImageView::verticalScrollHandler(CallbackData &callbackData)
|
|
{
|
|
mScrollInfo.handleVerticalScroll(callbackData);
|
|
return (CallbackData::ReturnType)FALSE;
|
|
}
|
|
|
|
CallbackData::ReturnType ImageView::eraseBackgroundHandler(CallbackData &callbackData)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
CallbackData::ReturnType ImageView::paintHandler(CallbackData &callbackData)
|
|
{
|
|
PaintInformation &paintInfo=*((PaintInformation*)callbackData.lParam());
|
|
PureDevice &paintDevice=(PureDevice&)paintInfo;
|
|
|
|
clearEmptyRegion(paintDevice);
|
|
if(mScrollInfo.sizeEvent())
|
|
{
|
|
mScrollInfo.sizeEvent(FALSE);
|
|
mImage.draw(paintDevice,Rect(0,0,mImage.width(),mImage.height()),Point(mScrollInfo.currScrollx(),mScrollInfo.currScrolly()));
|
|
}
|
|
if(mScrollInfo.scrollEvent()||(!mScrollInfo.sizeEvent()&&!mScrollInfo.scrollEvent()))
|
|
{
|
|
Rect paintRect(paintInfo.paintRect());
|
|
mScrollInfo.scrollEvent(FALSE);
|
|
paintRect.right(paintRect.right()-paintRect.left());
|
|
paintRect.bottom(paintRect.bottom()-paintRect.top());
|
|
mImage.draw(paintDevice,paintRect,Point(paintRect.left()+mScrollInfo.currScrollx(),paintRect.top()+mScrollInfo.currScrolly()));
|
|
}
|
|
return (CallbackData::ReturnType)FALSE;
|
|
}
|
|
|
|
void ImageView::clearEmptyRegion(PureDevice &pureDevice)
|
|
{
|
|
Rect imgRect;
|
|
Rect winRect;
|
|
Rect rtRect;
|
|
Rect btRect;
|
|
|
|
imgRect.right(mImage.width());
|
|
imgRect.bottom(mImage.height());
|
|
clientRect(winRect);
|
|
rtRect.left(winRect.right()>imgRect.right()?imgRect.right():winRect.right());
|
|
rtRect.right(winRect.right()>imgRect.right()?winRect.right():imgRect.right());
|
|
rtRect.bottom(winRect.bottom()>imgRect.bottom()?winRect.bottom():imgRect.bottom());
|
|
btRect.top(imgRect.bottom());
|
|
btRect.right(rtRect.left());
|
|
btRect.bottom(winRect.bottom());
|
|
pureDevice.fillRect(rtRect,mBkBrush);
|
|
pureDevice.fillRect(btRect,mBkBrush);
|
|
}
|
|
|
|
bool ImageView::open(const String &strPathFileName)
|
|
{
|
|
if(!mImage.open(strPathFileName,*this)){destroy();return false;}
|
|
mScrollInfo.scrollableObjectDimensions(mImage.width(),mImage.height());
|
|
show(SW_SHOW);
|
|
setTitle(strPathFileName);
|
|
invalidate(false);
|
|
setFocus();
|
|
return true;
|
|
}
|
|
|
|
void ImageView::operator=(Bitmap &someBitmap)
|
|
{
|
|
/* RGBQUAD FAR *pRGBQuad;
|
|
RGBStruct rgbStruct;
|
|
DWORD sizeBitmapInfo;
|
|
DWORD sizeImage;
|
|
HGLOBAL hGlobalSourceBitmapInfo;
|
|
HGLOBAL hGlobalSourceImage;
|
|
BITMAPINFO FAR *lpSourceBitmapInfo;
|
|
UHUGE *lpSourceImage;
|
|
|
|
hGlobalSourceBitmapInfo=someBitmap.lockedBitmapInfo();
|
|
#if defined(__FLAT__)
|
|
sizeBitmapInfo=::GlobalSize(hGlobalSourceBitmapInfo);
|
|
#else
|
|
sizeBitmapInfo=::GetSelectorLimit((UINT)hGlobalSourceBitmapInfo)+1L;
|
|
#endif
|
|
mhBMPGlobal=::GlobalAlloc(GMEM_FIXED,sizeBitmapInfo);
|
|
mpBI=(BITMAPINFO FAR *)::GlobalLock(mhBMPGlobal);
|
|
lpSourceBitmapInfo=(BITMAPINFO *)::GlobalLock(hGlobalSourceBitmapInfo);
|
|
Main::hmemcpy((UHUGE *)mpBI,(UHUGE *)lpSourceBitmapInfo,sizeBitmapInfo);
|
|
::GlobalUnlock(hGlobalSourceBitmapInfo);
|
|
sizeImage=((((mpBI->bmiHeader.biWidth*
|
|
mpBI->bmiHeader.biBitCount)+31)&~31)>>3)*
|
|
mpBI->bmiHeader.biHeight;
|
|
mhGlobalInvert=::GlobalAlloc(GMEM_FIXED,sizeImage);
|
|
mhpImageInvert=(UHUGE*)::GlobalLock(mhGlobalInvert);
|
|
hGlobalSourceImage=someBitmap.lockedImageData();
|
|
lpSourceImage=(UHUGE*)::GlobalLock(hGlobalSourceImage);
|
|
Main::hmemcpy(mhpImageInvert,lpSourceImage,sizeImage);
|
|
::GlobalUnlock(hGlobalSourceImage);
|
|
mWidth=(WORD)mpBI->bmiHeader.biWidth;
|
|
mHeight=(WORD)mpBI->bmiHeader.biHeight;
|
|
if(!(mMaxColors=(WORD)mpBI->bmiHeader.biClrUsed))
|
|
mMaxColors=1 << mpBI->bmiHeader.biBitCount;
|
|
for(int i=0;i<mMaxColors;i++)
|
|
{
|
|
pRGBQuad=(RGBQUAD FAR *)&mpBI->bmiColors[i];
|
|
rgbStruct.Red(pRGBQuad->rgbRed);
|
|
rgbStruct.Green(pRGBQuad->rgbGreen);
|
|
rgbStruct.Blue(pRGBQuad->rgbBlue);
|
|
mPaletteData.insert(&rgbStruct);
|
|
}
|
|
createPalette(); */
|
|
}
|
|
|
|
/*void ImageView::Paint(void)
|
|
{
|
|
RECT rect;
|
|
PAINTSTRUCT ps;
|
|
HDC hDC;
|
|
HPALETTE hOldPalette;
|
|
HWND activeWindow;
|
|
WORD menuState;
|
|
WORD errorCount=0;
|
|
|
|
::GetClientRect(GetHandle(),(RECT FAR *)&rect);
|
|
activeWindow=(HWND)LOWORD(::SendMessage(mhClientWindow,WM_MDIGETACTIVE,0,0L));
|
|
hDC=::BeginPaint(GetHandle(),&ps);
|
|
if(GetHandle()==activeWindow)hOldPalette=::SelectPalette(hDC,mhPalette,FALSE);
|
|
else hOldPalette=::SelectPalette(hDC,mhPalette,TRUE);
|
|
::RealizePalette(hDC);
|
|
menuState=::GetMenuState(mhSystemMenu,MenuConform,MF_BYCOMMAND);
|
|
if(!(menuState&MF_CHECKED))
|
|
::StretchDIBits(hDC,0,0,rect.right,rect.bottom,0,0,mWidth,mHeight,mhpImageInvert,(BITMAPINFO *)mpBI,DIB_RGB_COLORS,SRCCOPY);
|
|
else
|
|
{
|
|
while(!::StretchDIBits(hDC,0,0,mWidth,mHeight,0,0,mWidth,mHeight,mhpImageInvert,(BITMAPINFO *)mpBI,DIB_RGB_COLORS,SRCCOPY))
|
|
{
|
|
errorCount++;
|
|
::MessageBeep(0);
|
|
mWidth--;
|
|
mHeight--;
|
|
if((int)mWidth-1<0 || (int)mHeight-1<0)break;
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
Resize resizeImage(mWidth+1,mHeight+1,mWidth,mHeight,mhGlobalInvert);
|
|
HGLOBAL hGlobalTemp=resizeImage.resizeImage();
|
|
::GlobalFree(mhGlobalInvert);
|
|
mhGlobalInvert=hGlobalTemp;
|
|
mhpImageInvert=(UHUGE *)::GlobalLock(hGlobalTemp);
|
|
mpBI->bmiHeader.biWidth=mWidth;
|
|
mpBI->bmiHeader.biHeight=mHeight;
|
|
}
|
|
if(errorCount)updateCaption();
|
|
}
|
|
if(GetHandle()==activeWindow)::SelectPalette(hDC,hOldPalette,FALSE);
|
|
else ::SelectPalette(hDC,hOldPalette,TRUE);
|
|
::EndPaint(GetHandle(),&ps);
|
|
if(mlpGridMesh)mlpGridMesh->suspendMesh(FALSE);
|
|
} */
|
|
|
|
void ImageView::updateCaption(void)const
|
|
{
|
|
/* char Buffer[MaxFileName];
|
|
char *ptr;
|
|
|
|
::GetWindowText(GetHandle(),(LPSTR)Buffer,sizeof(Buffer));
|
|
ptr=Buffer+::strlen(Buffer)-1;
|
|
while(*ptr!='-')ptr--;
|
|
ptr+=2;
|
|
::sprintf(ptr,"%dx%dx%d",mWidth,mHeight,mMaxColors);
|
|
::SetWindowText(GetHandle(),(LPSTR)Buffer); */
|
|
}
|
|
|
|
void ImageView::modifySystemMenu(void)
|
|
{
|
|
/* if(mhSystemMenu)return;
|
|
|
|
mhSystemMenu=::GetSystemMenu(GetHandle(),FALSE);
|
|
::AppendMenu(mhSystemMenu,MF_SEPARATOR,0,0);
|
|
::AppendMenu(mhSystemMenu,MF_STRING|MF_CHECKED,MenuConform,(LPSTR)"Non-Conforming");
|
|
::DrawMenuBar(GetHandle()); */
|
|
}
|
|
|
|
void ImageView::handleDestroyEvent()
|
|
{
|
|
/* if(mpProcessImage)mpProcessImage->cancelThread();
|
|
if(mpSpacial)mpSpacial->cancelThread();
|
|
if(mpPerspectiveWarp)mpPerspectiveWarp->cancelThread();
|
|
if(mlpConvexTransform)mlpConvexTransform->cancelThread();
|
|
if(mlpClipboard)delete mlpClipboard;
|
|
mIsDestroyed=TRUE; */
|
|
return;
|
|
}
|
|
|
|
void ImageView::handleActivateEvent(WPARAM wParam,LPARAM /*lParam*/)
|
|
{
|
|
/* if(wParam)
|
|
{
|
|
if(mlpGridMesh)mlpGridMesh->suspendMesh(TRUE);
|
|
HDC inhDC(::GetDC(GetHandle()));
|
|
::SelectPalette(inhDC,mhPalette,FALSE);
|
|
::SendMessage(mhFrameWindow,WM_COMMAND,IDM_INVALIDATEMDIWINDOWS,MAKELPARAM(0,0));
|
|
if(::RealizePalette(inhDC)>0)::InvalidateRect(GetHandle(),0,TRUE);
|
|
::ReleaseDC(GetHandle(),inhDC);
|
|
#if defined(__FLAT__)
|
|
::SendMessage(mhClientWindow,WM_MDISETMENU,(WPARAM)mhViewMenu,(LPARAM)::GetSubMenu(mhViewMenu,0));
|
|
#else
|
|
::SendMessage(mhClientWindow,WM_MDISETMENU,FALSE,MAKELONG(mhViewMenu,::GetSubMenu(mhViewMenu,0)));
|
|
#endif
|
|
if(mToolbarVisibility&&mlpToolBar&&!mlpToolBar->isVisible())mlpToolBar->showWindow();
|
|
}
|
|
else
|
|
{
|
|
if(mlpToolBar&&mlpToolBar->isVisible())mlpToolBar->showWindow(FALSE);
|
|
if(mlpGridMesh)mlpGridMesh->showWindow(TRUE);
|
|
#if defined(__FLAT__)
|
|
::SendMessage(mhClientWindow,WM_MDISETMENU,(WPARAM)mhFrameMenu,(LPARAM)0);
|
|
#else
|
|
::SendMessage(mhClientWindow,WM_MDISETMENU,FALSE,MAKELONG(mhFrameMenu,0));
|
|
#endif
|
|
}
|
|
::DrawMenuBar(mhFrameWindow); */
|
|
return;
|
|
}
|
|
|
|
/* long ImageView::WndProc(UINT message,WPARAM wParam,LPARAM lParam)
|
|
{
|
|
switch(message)
|
|
{
|
|
case WM_CREATE :
|
|
{
|
|
char buffer[100];
|
|
|
|
mlpClipboard=new Clipboard(GetHandle());
|
|
assert(0!=mlpClipboard);
|
|
::SetWindowText(GetHandle(),(LPSTR)mPathFileName);
|
|
::sprintf(buffer,"%s - %dx%dx%d",mPathFileName,mWidth,mHeight,mMaxColors);
|
|
::SetWindowText(GetHandle(),(LPSTR)buffer);
|
|
modifySystemMenu();
|
|
mCapture=GetHandle();
|
|
::EnableMenuItem(mhViewMenu,MENU_PASTE,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
}
|
|
return FALSE;
|
|
case WM_CHANGECBCHAIN :
|
|
if(!mlpClipboard)break;
|
|
mlpClipboard->changeClipboardChain(message,wParam,lParam);
|
|
return FALSE;
|
|
case WM_DRAWCLIPBOARD :
|
|
if(!mlpClipboard)break;
|
|
if(mlpClipboard->drawClipboard(message,wParam,lParam))
|
|
::EnableMenuItem(mhViewMenu,MENU_PASTE,MF_BYCOMMAND|MF_ENABLED);
|
|
return FALSE;
|
|
case WM_LBUTTONDOWN :
|
|
mCapture.leftButtonDown(lParam);
|
|
return FALSE;
|
|
case WM_MOUSEMOVE :
|
|
mCapture.mouseMove(lParam);
|
|
return FALSE;
|
|
case WM_LBUTTONUP :
|
|
mCapture.leftButtonUp();
|
|
return FALSE;
|
|
case WM_PAINT :
|
|
Paint();
|
|
return FALSE;
|
|
case WM_MDIACTIVATE :
|
|
#if defined(__FLAT__)
|
|
handleActivateEvent((WPARAM)lParam,(LPARAM)wParam);
|
|
#else
|
|
handleActivateEvent(wParam,lParam);
|
|
#endif
|
|
return FALSE;
|
|
case WM_QUERYENDSESSION :
|
|
break;
|
|
case WM_DESTROY :
|
|
handleDestroyEvent();
|
|
return FALSE;
|
|
case WM_SYSCOMMAND :
|
|
handleSystemMenuEvent(wParam);
|
|
break;
|
|
case WM_COMMAND :
|
|
switch(GET_WM_COMMAND_ID(wParam,lParam))
|
|
{
|
|
case MenuConform :
|
|
::SendMessage(GetHandle(),WM_SYSCOMMAND,MenuConform,0L);
|
|
return FALSE;
|
|
case MENU_SMOOTHING :
|
|
imageProcessing();
|
|
return FALSE;
|
|
case MENU_RESIZE :
|
|
resizeImage();
|
|
return FALSE;
|
|
case MENU_TRANSLATE :
|
|
translateMatrix();
|
|
return FALSE;
|
|
case MENU_SHEAR :
|
|
shearTransform();
|
|
return FALSE;
|
|
case MENU_WARP_PERSPECTIVE :
|
|
warpPerspective();
|
|
return FALSE;
|
|
case MENU_WARP_CONVEX :
|
|
warpConvex();
|
|
return FALSE;
|
|
case MENU_CLIP :
|
|
menuClip();
|
|
return FALSE;
|
|
case MENU_DISSOLVE :
|
|
{
|
|
AdjustDissolve adjustDissolve(GetHandle());
|
|
adjustDissolve.adjustDissolve(mDissolveSchedule,mCurrentMeshFrames);
|
|
}
|
|
return FALSE;
|
|
case MENU_TBSIGMA :
|
|
{
|
|
FrameDialog frameDialog(GetHandle());
|
|
frameDialog.performFrameDialog(mCurrentMeshFrames);
|
|
}
|
|
return FALSE;
|
|
case MENU_TBLOAD :
|
|
case MENU_TBSAVE :
|
|
case MENU_TBTRANSFORMB :
|
|
case MENU_TBTRANSFORMA :
|
|
case IDM_WINLIST :
|
|
handleMeshRequest(wParam,lParam);
|
|
return FALSE;
|
|
case MENU_TBCLIP :
|
|
mCapture.reset();
|
|
if(mlpGridMesh)
|
|
{
|
|
delete mlpGridMesh;
|
|
mlpGridMesh=0;
|
|
}
|
|
return FALSE;
|
|
case MENU_TBMESH :
|
|
if(!mlpGridMesh)mlpGridMesh=new GridMesh(GetHandle(),mWidth,mHeight);
|
|
else mlpGridMesh->newMesh(mlpGridMesh->gridLines()+2);
|
|
return FALSE;
|
|
case MENU_FILE_SAVEBITMAP :
|
|
saveBitmap();
|
|
return FALSE;
|
|
case MENU_PALETTE_VIEW :
|
|
{
|
|
PaletteDialog viewPalette(GetHandle(),mhPalette);
|
|
viewPalette.showPalette();
|
|
return FALSE;
|
|
}
|
|
case IDM_TOOLBAR :
|
|
handleToolbarToggle();
|
|
break;
|
|
default :
|
|
return FALSE;
|
|
}
|
|
}
|
|
return ::DefMDIChildProc(GetHandle(),message,wParam,lParam);
|
|
} */
|
|
|
|
// **************************************************************
|
|
|
|
void ImageView::handleToolbarToggle(void)
|
|
{
|
|
/* String showToolbarString(STRING_SHOWTOOLBAR,Main::processInstance());
|
|
String hideToolbarString(STRING_HIDETOOLBAR,Main::processInstance());
|
|
String menuString;
|
|
|
|
::GetMenuString(mhViewMenu,IDM_TOOLBAR,menuString,String::MaxString,MF_BYCOMMAND);
|
|
if(showToolbarString==menuString)
|
|
{
|
|
::ModifyMenu(mhViewMenu,IDM_TOOLBAR,MF_STRING|MF_ENABLED,IDM_TOOLBAR,(LPSTR)hideToolbarString);
|
|
mlpToolBar->showWindow(TRUE);
|
|
mToolbarVisibility=TRUE;
|
|
}
|
|
else
|
|
{
|
|
::ModifyMenu(mhViewMenu,IDM_TOOLBAR,MF_STRING|MF_ENABLED,IDM_TOOLBAR,(LPSTR)showToolbarString);
|
|
mlpToolBar->showWindow(FALSE);
|
|
mToolbarVisibility=FALSE;
|
|
}
|
|
::DrawMenuBar(GetHandle()); */
|
|
}
|
|
|
|
void ImageView::handleMeshRequest(WPARAM wParam,LPARAM lParam)
|
|
{
|
|
/* String meshFileName(mPathFileName);
|
|
String meshPathFileName;
|
|
|
|
IniFile iniSettings;
|
|
iniSettings.makeFileName(meshFileName);
|
|
meshFileName.token(".\0");
|
|
meshFileName+=".MSH";
|
|
meshPathFileName=iniSettings.meshDirectory();
|
|
meshPathFileName+=meshFileName;
|
|
switch(wParam)
|
|
{
|
|
case MENU_TBLOAD :
|
|
if(!mlpGridMesh)mlpGridMesh=new GridMesh(GetHandle(),mWidth,mHeight,GridMesh::NoShow);
|
|
mlpGridMesh->loadMesh(meshPathFileName);
|
|
break;
|
|
case MENU_TBTRANSFORMA :
|
|
if(!mlpGridMesh){::MessageBeep(0);break;}
|
|
meshWarp();
|
|
break;
|
|
case MENU_TBTRANSFORMB :
|
|
if(!mlpGridMesh){::MessageBeep(0);break;}
|
|
::PostMessage(mhFrameWindow,WM_COMMAND,IDM_GETWINLIST,MAKELPARAM(GetHandle(),0));
|
|
break;
|
|
case IDM_WINLIST :
|
|
{
|
|
WORD itemIndex;
|
|
Block<ViewContainer> *lpViewBlock=(Block<ViewContainer>*)(lParam);
|
|
if(!lpViewBlock||!lpViewBlock->size()){::MessageBeep(0);break;}
|
|
ViewSelect selectView(GetHandle());
|
|
if(selectView.selectView(*lpViewBlock,itemIndex,mWidth,mHeight))meshWarp((*lpViewBlock)[itemIndex].windowPtr());
|
|
delete lpViewBlock;
|
|
}
|
|
break;
|
|
case MENU_TBSAVE :
|
|
if(!mlpGridMesh)break;
|
|
mlpGridMesh->saveMesh(meshPathFileName);
|
|
break;
|
|
} */
|
|
return;
|
|
}
|
|
|
|
void ImageView::handleSystemMenuEvent(WPARAM wParam)const
|
|
{
|
|
/* WORD menuState;
|
|
|
|
switch(wParam)
|
|
{
|
|
case MenuConform :
|
|
menuState=::GetMenuState(mhSystemMenu,MenuConform,MF_BYCOMMAND);
|
|
::CheckMenuItem(mhSystemMenu,MenuConform,MF_BYCOMMAND |
|
|
(menuState&MF_CHECKED?MF_UNCHECKED:MF_CHECKED));
|
|
::DrawMenuBar(GetHandle());
|
|
::InvalidateRect(GetHandle(),NULL,TRUE);
|
|
} */
|
|
}
|
|
|
|
void ImageView::enableMenu(const char isEnabled)const
|
|
{
|
|
/* if(isEnabled)
|
|
{
|
|
::EnableMenuItem(mhViewMenu,MENU_CUT,MF_BYCOMMAND|MF_ENABLED);
|
|
::EnableMenuItem(mhViewMenu,MENU_COPY,MF_BYCOMMAND|MF_ENABLED);
|
|
::EnableMenuItem(mhViewMenu,MENU_PASTE,MF_BYCOMMAND|MF_ENABLED);
|
|
::EnableMenuItem(mhViewMenu,MENU_SMOOTHING,MF_BYCOMMAND|MF_ENABLED);
|
|
::EnableMenuItem(mhViewMenu,MENU_RESIZE,MF_BYCOMMAND|MF_ENABLED);
|
|
::EnableMenuItem(mhViewMenu,MENU_TRANSLATE,MF_BYCOMMAND|MF_ENABLED);
|
|
::EnableMenuItem(mhViewMenu,MENU_WARP_PERSPECTIVE,MF_BYCOMMAND|MF_ENABLED);
|
|
::EnableMenuItem(mhViewMenu,MENU_FILE_SAVEBITMAP,MF_BYCOMMAND|MF_ENABLED);
|
|
}
|
|
else
|
|
{
|
|
::EnableMenuItem(mhViewMenu,MENU_CUT,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
::EnableMenuItem(mhViewMenu,MENU_COPY,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
::EnableMenuItem(mhViewMenu,MENU_PASTE,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
::EnableMenuItem(mhViewMenu,MENU_SMOOTHING,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
::EnableMenuItem(mhViewMenu,MENU_RESIZE,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
::EnableMenuItem(mhViewMenu,MENU_TRANSLATE,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
::EnableMenuItem(mhViewMenu,MENU_WARP_PERSPECTIVE,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
::EnableMenuItem(mhViewMenu,MENU_FILE_SAVEBITMAP,MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
|
|
} */
|
|
}
|
|
|
|
void ImageView::imageProcessing(void)
|
|
{
|
|
/* enableMenu(FALSE);
|
|
mpProcessImage=new Process(mhPalette,mhpImageInvert,mWidth,mHeight);
|
|
if(mpProcessImage->showProcess(GetHandle(),mPathFileName) && !mIsDestroyed)
|
|
::InvalidateRect(GetHandle(),NULL,TRUE);
|
|
if(!mIsDestroyed)enableMenu(TRUE);
|
|
delete mpProcessImage;
|
|
mpProcessImage=0; */
|
|
}
|
|
|
|
void ImageView::resizeImage(void)
|
|
{
|
|
double sizeFactor;
|
|
Factor resizeFactor(*this,"Resize Factor");
|
|
if(!resizeFactor.showFactor(sizeFactor,sizeFactor)||0.00==sizeFactor)return;
|
|
|
|
|
|
/* HGLOBAL hGlobal;
|
|
double sizeFactor;
|
|
|
|
Factor resizeFactor(GetHandle(),"Resize Factor");
|
|
if(!resizeFactor.showFactor(sizeFactor,sizeFactor)||!sizeFactor)return;
|
|
enableMenu(FALSE);
|
|
mpSpacial=new SpacialTransform(mhPalette,mhpImageInvert,mWidth,mHeight,sizeFactor);
|
|
hGlobal=mpSpacial->resizeImage();
|
|
if(mpSpacial->isCancelled())
|
|
{
|
|
delete mpSpacial;
|
|
mpSpacial=0;
|
|
return;
|
|
}
|
|
delete mpSpacial;
|
|
mpSpacial=0;
|
|
if(hGlobal)
|
|
{
|
|
mWidth*=(sizeFactor/100.00);
|
|
mHeight*=(sizeFactor/100.00);
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
::GlobalFree(mhGlobalInvert);
|
|
mhGlobalInvert=hGlobal;
|
|
mhpImageInvert=(UHUGE *)::GlobalLock(mhGlobalInvert);
|
|
mpBI->bmiHeader.biWidth=mWidth;
|
|
mpBI->bmiHeader.biHeight=mHeight;
|
|
}
|
|
::InvalidateRect(GetHandle(),NULL,TRUE);
|
|
enableMenu(TRUE);
|
|
updateCaption(); */
|
|
}
|
|
|
|
void ImageView::menuClip(void)
|
|
{
|
|
/* RECT copyRect;
|
|
HGLOBAL hGlobalResizedImage;
|
|
UHUGE *ptrResizedImage;
|
|
|
|
if(!mCapture.hasRectangle())return;
|
|
mCapture.boundedRect(copyRect);
|
|
enableMenu(FALSE);
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
Resize resizeImage(mWidth,mHeight,copyRect,mhGlobalInvert);
|
|
if(0!=(hGlobalResizedImage=resizeImage.resizeImage()))
|
|
{
|
|
::GlobalFree(mhGlobalInvert);
|
|
ptrResizedImage=(UHUGE *)::GlobalLock(hGlobalResizedImage);
|
|
mhGlobalInvert=hGlobalResizedImage;
|
|
mhpImageInvert=ptrResizedImage;
|
|
mpBI->bmiHeader.biWidth=mWidth=(copyRect.right-copyRect.left)+1;
|
|
mpBI->bmiHeader.biHeight=mHeight=(copyRect.bottom-copyRect.top)+1;
|
|
::InvalidateRect(GetHandle(),NULL,TRUE);
|
|
}
|
|
else ::GlobalLock(mhGlobalInvert);
|
|
updateCaption();
|
|
enableMenu(TRUE); */
|
|
}
|
|
|
|
void ImageView::saveBitmap(void)
|
|
{
|
|
/* char bitmapName[MaxFileName];
|
|
|
|
SelectFile selector(GetHandle(),SelectFile::Write);
|
|
selector.SetFileSpec(String(STRING_ASTERISKDOTBMP,Main::processInstance()));
|
|
if(selector.GetFileName(bitmapName,sizeof(bitmapName)))
|
|
{
|
|
waitCursor(TRUE);
|
|
Bitmap bitmapImage(bitmapName,mhGlobalInvert,mhBMPGlobal);
|
|
bitmapImage.saveBitmap();
|
|
waitCursor(FALSE);
|
|
} */
|
|
}
|
|
|
|
void ImageView::translateMatrix(void)
|
|
{
|
|
/* UHUGE *ptr;
|
|
double xFactor;
|
|
double yFactor;
|
|
|
|
Factor resizeFactor(GetHandle(),"Translate Factor");
|
|
if(!resizeFactor.showFactor(yFactor,xFactor))return;
|
|
if(!yFactor && !xFactor)return;
|
|
enableMenu(FALSE);
|
|
waitCursor(TRUE);
|
|
yFactor*=-1;
|
|
xFactor*=-1;
|
|
HGLOBAL hGlobal=::GlobalAlloc(GMEM_FIXED,(LONG)mWidth*(LONG)mHeight);
|
|
ptr=(UHUGE*)::GlobalLock(hGlobal);
|
|
TranslationMatrix translation(mHeight,mWidth,(int)xFactor,(int)yFactor,&mhpImageInvert,&ptr);
|
|
translation.performTranslation();
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
::GlobalFree(mhGlobalInvert);
|
|
mhGlobalInvert=hGlobal;
|
|
mhpImageInvert=ptr;
|
|
::InvalidateRect(GetHandle(),NULL,TRUE);
|
|
waitCursor(FALSE);
|
|
enableMenu(TRUE); */
|
|
}
|
|
|
|
void ImageView::shearTransform(void)
|
|
{
|
|
/* HGLOBAL hGlobalTemp;
|
|
WORD width(mWidth);
|
|
WORD height(mHeight);
|
|
double xFactor(0.3);
|
|
double yFactor(0.00);
|
|
|
|
Factor shearFactor(GetHandle(),"Shear Factors");
|
|
if(!shearFactor.showFactor(xFactor,yFactor))return;
|
|
Shear shearTransform;
|
|
hGlobalTemp=shearTransform.performShear
|
|
(width,height,xFactor,yFactor,mhpImageInvert);
|
|
if(hGlobalTemp)
|
|
{
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
::GlobalFree(mhGlobalInvert);
|
|
mpBI->bmiHeader.biWidth=mWidth=width;
|
|
mpBI->bmiHeader.biHeight=mHeight=height;
|
|
mhGlobalInvert=hGlobalTemp;
|
|
mhpImageInvert=(UHUGE*)::GlobalLock(hGlobalTemp);
|
|
}
|
|
::InvalidateRect(GetHandle(),NULL,TRUE); */
|
|
}
|
|
|
|
void ImageView::warpPerspective(void)
|
|
{
|
|
/* HGLOBAL hGlobalTemp;
|
|
Factor::Operation widthOperation;
|
|
Factor::Operation heightOperation;
|
|
double widthIncremental;
|
|
double heightIncremental;
|
|
double wRow;
|
|
double wCol;
|
|
WORD isCancelled;
|
|
|
|
Factor resizeFactor(GetHandle(),"Perpective Warp");
|
|
if(!resizeFactor.showFactor(
|
|
wRow,wCol,
|
|
widthIncremental,widthOperation,
|
|
heightIncremental,heightOperation
|
|
))return;
|
|
enableMenu(FALSE);
|
|
if(Factor::None==widthOperation&&Factor::None==heightOperation)
|
|
mpPerspectiveWarp=new PerspectiveWarp(mWidth,mHeight,mhpImageInvert,wRow,wCol);
|
|
else
|
|
mpPerspectiveWarp=new PerspectiveWarp(mWidth,mHeight,wRow,wCol,
|
|
(PerspectiveWarp::Operation)widthOperation,widthIncremental,
|
|
(PerspectiveWarp::Operation)heightOperation,heightIncremental,mhpImageInvert);
|
|
hGlobalTemp=mpPerspectiveWarp->performPerspectiveWarp();
|
|
isCancelled=mpPerspectiveWarp->isCancelled();
|
|
delete mpPerspectiveWarp;
|
|
mpPerspectiveWarp=0;
|
|
enableMenu(TRUE);
|
|
if(isCancelled)return;
|
|
if(hGlobalTemp)
|
|
{
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
::GlobalFree(mhGlobalInvert);
|
|
mhGlobalInvert=hGlobalTemp;
|
|
mhpImageInvert=(UHUGE*)::GlobalLock(hGlobalTemp);
|
|
}
|
|
::InvalidateRect(GetHandle(),NULL,TRUE); */
|
|
}
|
|
|
|
void ImageView::handleWarpConvex(void)
|
|
{
|
|
Convex convex;
|
|
Image image;
|
|
mImage=convex.performConvex(mImage,*this);
|
|
invalidate(false);
|
|
/* HGLOBAL hGlobalTemp;
|
|
WORD isCancelled;
|
|
|
|
mlpConvexTransform=new Convex;
|
|
hGlobalTemp=mlpConvexTransform->performConvex(mWidth,mHeight,mhpImageInvert);
|
|
isCancelled=mlpConvexTransform->isCancelled();
|
|
delete mlpConvexTransform;
|
|
mlpConvexTransform=0;
|
|
if(isCancelled)return;
|
|
if(hGlobalTemp)
|
|
{
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
::GlobalFree(mhGlobalInvert);
|
|
mhGlobalInvert=hGlobalTemp;
|
|
mhpImageInvert=(UHUGE*)::GlobalLock(hGlobalTemp);
|
|
}
|
|
::InvalidateRect(GetHandle(),NULL,TRUE); */
|
|
}
|
|
|
|
// *********************************************************************************
|
|
|
|
void ImageView::meshWarp(Direction warpDirection)
|
|
{
|
|
/* Vector<FloatPairs> sourcePairs;
|
|
Vector<FloatPairs> destPairs;
|
|
Vector<MeshFrames::VectoredPairs> meshFrames;
|
|
Vector<Point> sourcePoints;
|
|
Vector<Point> destPoints;
|
|
Block<String> intermediatePathFileNames;
|
|
HGLOBAL hGlobalOriginal;
|
|
UHUGE *lpOriginal;
|
|
int originalWidth;
|
|
int originalHeight;
|
|
HGLOBAL hGlobalTemp(0);
|
|
MeshFrames meshFrame;
|
|
int newWidth;
|
|
int newHeight;
|
|
size_t size;
|
|
|
|
mlpGridMesh->retrieveMesh(sourcePoints,destPoints);
|
|
if((size=(int)sourcePoints.size())!=destPoints.size())return;
|
|
sourcePairs.size(destPairs.size(size));
|
|
for(int i=0;i<size;i++)
|
|
{
|
|
sourcePairs[i].setPairs(sourcePoints[i].xPoint(),sourcePoints[i].yPoint());
|
|
destPairs[i].setPairs(destPoints[i].xPoint(),destPoints[i].yPoint());
|
|
}
|
|
if(WarpForward==warpDirection)
|
|
meshFrame.interpolateMeshFrames(sourcePairs,destPairs,meshFrames,mCurrentMeshFrames);
|
|
else
|
|
meshFrame.interpolateMeshFrames(destPairs,sourcePairs,meshFrames,mCurrentMeshFrames);
|
|
hGlobalOriginal=::GlobalAlloc(GMEM_FIXED,(LONG)mWidth*(LONG)mHeight);
|
|
lpOriginal=(UHUGE*)::GlobalLock(hGlobalOriginal);
|
|
originalWidth=mWidth;
|
|
originalHeight=mHeight;
|
|
Main::hmemcpy(lpOriginal,mhpImageInvert,(LONG)mWidth*(LONG)mHeight);
|
|
sequentialNames(mPathFileName,intermediatePathFileNames,mCurrentMeshFrames);
|
|
Bitmap bitmapImage(intermediatePathFileNames[0],hGlobalOriginal,mhBMPGlobal);
|
|
bitmapImage.saveBitmap();
|
|
for(i=0;i<mCurrentMeshFrames-1;i++)
|
|
{
|
|
MeshWarp meshWarp(mhPalette,lpOriginal,originalWidth,originalHeight);
|
|
hGlobalTemp=meshWarp.performWarp(sourcePairs,meshFrames[i],mlpGridMesh->rowCols(),newWidth,newHeight);
|
|
::GlobalUnlock(mhGlobalInvert);
|
|
::GlobalFree(mhGlobalInvert);
|
|
if(!hGlobalTemp)break;
|
|
mhGlobalInvert=hGlobalTemp;
|
|
mhpImageInvert=(UHUGE*)::GlobalLock(hGlobalTemp);
|
|
mpBI->bmiHeader.biWidth=mWidth=newWidth;
|
|
mpBI->bmiHeader.biHeight=mHeight=newHeight;
|
|
::InvalidateRect(GetHandle(),NULL,TRUE);
|
|
::UpdateWindow(GetHandle());
|
|
Bitmap bitmapImage(intermediatePathFileNames[i+1],mhGlobalInvert,mhBMPGlobal);
|
|
bitmapImage.saveBitmap();
|
|
}
|
|
if(!hGlobalTemp)
|
|
{
|
|
String tempString;
|
|
::sprintf(tempString,"Warp failed at %d",i);
|
|
::MessageBox(GetHandle(),(LPSTR)tempString,(LPSTR)"WARP ERROR",MB_ICONASTERISK);
|
|
mhGlobalInvert=hGlobalOriginal;
|
|
mhpImageInvert=lpOriginal;
|
|
mpBI->bmiHeader.biWidth=mWidth=originalWidth;
|
|
mpBI->bmiHeader.biHeight=mHeight=originalHeight;
|
|
}
|
|
else
|
|
{
|
|
::GlobalUnlock(hGlobalOriginal);
|
|
::GlobalFree(hGlobalOriginal);
|
|
}
|
|
if(WarpForward==warpDirection)createProjectFile(intermediatePathFileNames);
|
|
::InvalidateRect(GetHandle(),NULL,TRUE);
|
|
mlpGridMesh->showWindow(); */
|
|
}
|
|
|
|
void ImageView::meshWarp(ImageView *lpTargetView)
|
|
{
|
|
/* Block<String> intermediateSrcImage;
|
|
Block<String> intermediateDstImage;
|
|
CrossDissolve crossDissolve;
|
|
WORD currentTargetFrames;
|
|
|
|
meshWarp();
|
|
currentTargetFrames=lpTargetView->mCurrentMeshFrames;
|
|
lpTargetView->mCurrentMeshFrames=mCurrentMeshFrames;
|
|
lpTargetView->meshWarp(WarpReverse);
|
|
sequentialNames(mPathFileName,intermediateSrcImage,mCurrentMeshFrames);
|
|
lpTargetView->sequentialNames(lpTargetView->mPathFileName,intermediateDstImage,lpTargetView->mCurrentMeshFrames);
|
|
if(mDissolveSchedule.size())
|
|
crossDissolve.crossDissolve(intermediateSrcImage,intermediateDstImage,mDissolveSchedule);
|
|
else crossDissolve.crossDissolve(intermediateSrcImage,intermediateDstImage);
|
|
lpTargetView->mCurrentMeshFrames=currentTargetFrames; */
|
|
}
|
|
|
|
void ImageView::createProjectFile(Block<String> &pathFileNames)
|
|
{
|
|
/* String projectIDString(STRING_PROJECTIDSTRING,Main::processInstance());
|
|
String projectExtension(STRING_PROJECTEXTENSION,Main::processInstance());
|
|
String carriageReturn(STRING_CRLF,Main::processInstance());
|
|
String dotString(STRING_DOT,Main::processInstance());
|
|
String fileNameString;
|
|
size_t size((int)pathFileNames.size());
|
|
|
|
if(!size)return;
|
|
fileNameString=pathFileNames[0];
|
|
fileNameString.token(dotString);
|
|
fileNameString+=projectExtension;
|
|
ofstream outputProject(fileNameString);
|
|
if(!outputProject.fail()&&!outputProject.bad())
|
|
{
|
|
outputProject << (LPSTR)projectIDString << (LPSTR)carriageReturn;
|
|
for(int i=0;i<size;i++)outputProject << (LPSTR)pathFileNames[i] << (LPSTR)carriageReturn;
|
|
} */
|
|
}
|
|
|
|
void ImageView::sequentialNames(const String &pathFileName,Block<String> &pathFileNames,int nFrames)
|
|
{
|
|
/* IniFile iniSettings;
|
|
String currentExtension(STRING_MESHEXTENSION,Main::processInstance());
|
|
String dotString(STRING_DOT,Main::processInstance());
|
|
String tempString(pathFileName);
|
|
String intermediatePathFileName;
|
|
|
|
pathFileNames.remove();
|
|
iniSettings.makeFileName(tempString);
|
|
intermediatePathFileName=iniSettings.projectDirectory();
|
|
intermediatePathFileName+=tempString;
|
|
for(int i=0;i<nFrames;i++)
|
|
{
|
|
intermediatePathFileName.token(dotString);
|
|
::sprintf(currentExtension,".%03d",i);
|
|
intermediatePathFileName+=currentExtension;
|
|
pathFileNames.insert(&intermediatePathFileName);
|
|
} */
|
|
}
|
|
|
|
bool ImageView::operator==(const ImageView &imageView)const
|
|
{
|
|
String strThisTitle;
|
|
String strOtherTitle;
|
|
|
|
windowText(strThisTitle);
|
|
imageView.windowText(strOtherTitle);
|
|
return strThisTitle==strOtherTitle;
|
|
}
|
|
|
|
void ImageView::setTitle(const String &strTitle)
|
|
{
|
|
String strCaption;
|
|
String strString;
|
|
|
|
windowText(strCaption);
|
|
strString=strCaption;
|
|
strCaption=strCaption.betweenString(0,' ');
|
|
if(strCaption.isNull())strCaption=strString;
|
|
strCaption+=String(" - [")+strTitle+String("]");
|
|
setCaption(strCaption);
|
|
}
|
|
|
|
void ImageView::showMesh(void)
|
|
{
|
|
if(mGridMesh.isOkay())mGridMesh->newMesh(mGridMesh->gridLines()+2);
|
|
else
|
|
{
|
|
mGridMesh.destroy();
|
|
mGridMesh=::new GridMesh(*this,mImage.width(),mImage.height());
|
|
mGridMesh.disposition(PointerDisposition::Delete);
|
|
mGridMesh->showWindow();
|
|
}
|
|
}
|
|
|
|
void ImageView::noMesh(void)
|
|
{
|
|
if(!mGridMesh.isOkay())return;
|
|
mGridMesh.destroy();
|
|
}
|
|
|
|
void ImageView::handleFrames(void)
|
|
{
|
|
FrameDialog frameDialog(*this);
|
|
frameDialog.perform(mCurrentMeshFrames);
|
|
}
|
|
|
|
// ***** virtual overloads
|
|
|
|
void ImageView::preRegister(WNDCLASS &wndClass)
|
|
{
|
|
wndClass.style|=CS_SAVEBITS|CS_OWNDC;
|
|
wndClass.hbrBackground=(HBRUSH)::GetStockObject(GRAY_BRUSH);
|
|
}
|
|
|
|
void ImageView::preCreate(MDICREATESTRUCT &createStruct)
|
|
{
|
|
createStruct.style=WS_SYSMENU|WS_CAPTION|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_VSCROLL|WS_HSCROLL;
|
|
}
|