bool nuiCoverFlow::KeyDown(const nglKeyEvent& rEvent)
{
if (rEvent.mKey == NK_LEFT)
{
SelectImage(mSelectedImage - 1);
return true;
}
else if (rEvent.mKey == NK_RIGHT)
{
SelectImage(mSelectedImage + 1);
return true;
}
return false;
}
bool nuiCoverFlow::MouseClicked(nuiSize X, nuiSize Y, nglMouseInfo::Flags Button)
{
if (Button & nglMouseInfo::ButtonWheelUp || Button & nglMouseInfo::ButtonWheelLeft)
{
SelectImage(mSelectedImage - 1);
return true;
}
else if (Button & nglMouseInfo::ButtonWheelDown || Button & nglMouseInfo::ButtonWheelRight)
{
SelectImage(mSelectedImage + 1);
return true;
}
return true;
}
/*
* CloseCurrentImage - Gets the current image the user is editing and deletes
* the node from the linked list and sends a message to
* destroy the mdi child (this will activate another
* child then).
*/
void CloseCurrentImage( HWND hwnd )
{
img_node *node;
char file_name[ _MAX_PATH ];
BOOL ret;
node = SelectImage( hwnd );
if (!node) return;
ret = DestroyWindow( _wpi_getframe(node->viewhwnd) );
GetFnameFromPath( node->fname, file_name );
DeleteUndoStack( hwnd );
if ( !DeleteNode(hwnd) ) {
WImgEditError( WIE_ERR_BAD_HWND, WIE_INTERNAL_002 );
return;
}
DeleteActiveImage();
ClearImageText();
GrayEditOptions();
PrintHintTextByID( WIE_FILEHASBEENCLOSED, file_name );
SetWindowText( _wpi_getframe(HMainWindow), IEAppTitle );
#ifdef __OS2_PM__
ret = DestroyWindow( _wpi_getframe(hwnd) );
#else
SendMessage(ClientWindow, WM_MDIDESTROY, (WPARAM)hwnd, 0L);
#endif
} /* CloseCurrentImage */
void nuiCoverFlow::DelImage(int32 index)
{
mImages[index]->Release();
mImages.erase(mImages.begin() + index);
SelectImage(mSelectedImage);
Invalidate();
}
/*
* DrawLine - Draws a line on the drawing area.
*/
void DrawLine( HWND hwnd, WPI_POINT *start_pt, WPI_POINT *end_pt, int mousebutton )
{
COLORREF colour;
COLORREF dithered;
WPI_POINT imgstart_pt;
WPI_POINT imgend_pt;
wie_clrtype type;
img_node *node;
CheckBounds( hwnd, start_pt );
CheckBounds( hwnd, end_pt );
imgstart_pt.x = start_pt->x / pointSize.x;
imgstart_pt.y = start_pt->y / pointSize.y;
imgend_pt.x = end_pt->x / pointSize.x;
imgend_pt.y = end_pt->y / pointSize.y;
dithered = GetSelectedColour(mousebutton, &colour, &type);
if (type == SCREEN_CLR) {
LineXorAnd(BLACK, WHITE, &imgstart_pt, &imgend_pt);
} else if (type == INVERSE_CLR) {
LineXorAnd(WHITE, WHITE, &imgstart_pt, &imgend_pt);
} else {
LineXorAnd(colour, BLACK, &imgstart_pt, &imgend_pt);
}
node = SelectImage( hwnd );
InvalidateRect(node->viewhwnd, NULL, FALSE);
BlowupImage( hwnd, NULL );
} /* DrawLine */
/*
* GetPointSize - returns the point size.
*/
WPI_POINT GetPointSize( HWND hwnd )
{
WPI_POINT pt = {0, 0};
img_node *node;
WPI_RECT rc;
int width;
int height;
node = SelectImage( hwnd );
if (!node) return( pt );
GetClientRect( hwnd, &rc );
width = _wpi_getwidthrect(rc);
height = _wpi_getheightrect(rc);
pt.x = width / node->width;
pt.y = height / node->height;
if( pt.x == 0 ) {
pt.x = 1;
}
if( pt.y == 0 ) {
pt.y = 1;
}
return( pt );
} /* GetPointSize */
/*
* BkColorEnumProc - used to change the background color of all MDI children
*/
BOOL CALLBACK BkColorEnumProc( HWND hwnd, LONG lparam )
{
img_node *node;
lparam = lparam;
if( _wpi_getowner( hwnd ) ) {
return( TRUE );
}
if( _wpi_isiconic( hwnd ) ) {
return( TRUE );
}
node = SelectImage( _wpi_getclient( hwnd ) );
if( node == NULL ) {
return( TRUE );
}
if( node->imgtype == BITMAP_IMG ) {
return( TRUE );
}
InvalidateRect( _wpi_getclient( hwnd ), NULL, FALSE );
InvalidateRect( node->viewhwnd, NULL, FALSE );
return( TRUE );
} /* BkColorEnumProc */
void nuiCoverFlow::SelectImageNow(nuiTexture* pTexture)
{
SelectImage(pTexture);
mPos = mSelectedImage;
mTimer.Stop();
Invalidate();
}
void nuiCoverFlow::SelectImageNow(int32 index)
{
SelectImage(index);
mPos = mSelectedImage;
mTimer.Stop();
Invalidate();
}
void QmitkActiveSurfaceToolGUI::UpdateSelectedImageBox(int selection)
{
//std::cout << "hi from " << __FUNCSIG__ << std::endl;
m_SelectImageBox->setCurrentIndex(selection);
SelectImage(selection);
//std::cout << "ciao from " << __FUNCSIG__ << std::endl;
}
void CImageExplorer::OpenImage(QString &fileName)
{
QPointF pos(GetBorders().left,GetBorders().top);
if(!iImages.isEmpty())
{
CImage *lastImage = iImages.back();
pos.setY (lastImage->GetPosition().y() + lastImage->GetSize().y());
}
pos+=iPosition;
int width = iSize.x()-GetBorders().right-GetBorders().left-iScrollBar->size().width();
QPointF size(width,width);
CImage *newImage;
if(fileName.isEmpty()){
return;
}
try
{
newImage = new CImage(iParentWindow,fileName,pos,size);
}
catch(TextureNotCreatedException &e)
{
QMessageBox msgBox(QMessageBox::Warning, tr("QMessageBox::warning()"),
QString("Could not allocate texture - TextureNotCreatedException"), 0, MainWindow::iSelfS);
msgBox.addButton(tr("&Continue"), QMessageBox::RejectRole);
msgBox.exec();
return;
}
catch(DicomFramesException &e)
{
QMessageBox msgBox(QMessageBox::Warning, tr("QMessageBox::warning()"),
QString("Could not load the image - bad format"), 0, MainWindow::iSelfS);
msgBox.addButton(tr("&Continue"), QMessageBox::RejectRole);
msgBox.exec();
return;
}
newImage->SetMoveability (false);
newImage->SetResizeability (false);
newImage->SetTextDisplay(EDisplayTextAll, false);
iImages.append (newImage);
SelectImage(newImage);
GLenum err = glGetErr();
if(CGLWidget::GetInstance())
{
CGLWidget::GetInstance()->updateGL();
}
err = glGetErr();
if(CInfoPanel::GetInstance())
{
CInfoPanel::GetInstance()->SetImageExplorerInfoView();
}
err = glGetErr();
//CImage *im = new CImage(iParentWindow,fileName,pos,size);
}
HRESULT STDMETHODCALLTYPE CBrandBand::SetSite(IUnknown* pUnkSite)
{
CComPtr<IBrowserService> browserService;
CComPtr<IOleWindow> oleWindow;
CComPtr<IServiceProvider> serviceProvider;
CComPtr<IProfferService> profferService;
HWND parentWindow;
HWND hwnd;
HRESULT hResult;
fSite.Release();
if (pUnkSite == NULL)
{
hResult = AtlUnadvise(fSite, DIID_DWebBrowserEvents, fAdviseCookie);
// TODO: revoke brand band service
return S_OK;
}
// get window handle of parent
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IDockingWindowSite, &fSite));
if (FAILED_UNEXPECTEDLY(hResult))
return hResult;
parentWindow = NULL;
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IOleWindow, &oleWindow));
if (SUCCEEDED(hResult))
hResult = oleWindow->GetWindow(&parentWindow);
if (!::IsWindow(parentWindow))
return E_FAIL;
// create worker window in parent window
hwnd = SHCreateWorkerWindowW(0, parentWindow, 0,
WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, NULL, 0);
if (hwnd == NULL)
return E_FAIL;
SubclassWindow(hwnd);
// take advice to watch events
hResult = pUnkSite->QueryInterface(IID_PPV_ARG(IServiceProvider, &serviceProvider));
if (SUCCEEDED(hResult))
{
hResult = serviceProvider->QueryService(
SID_SBrandBand, IID_PPV_ARG(IProfferService, &profferService));
if (SUCCEEDED(hResult))
hResult = profferService->ProfferService(SID_SBrandBand,
static_cast<IServiceProvider *>(this), &fProfferCookie);
hResult = serviceProvider->QueryService(SID_SShellBrowser,
IID_PPV_ARG(IBrowserService, &browserService));
if (SUCCEEDED(hResult))
hResult = AtlAdvise(browserService, static_cast<IDispatch *>(this), DIID_DWebBrowserEvents, &fAdviseCookie);
}
// ignore any hResult errors up to here - they are nonfatal
hResult = S_OK;
SelectImage();
return hResult;
}
void nuiCoverFlow::SelectImage(nuiTexture* pTexture)
{
for (int32 i = 0; i < mImages.size(); i++)
{
if (mImages[i] == pTexture)
{
SelectImage(i);
return;
}
}
}
/*
* HideViewWindow - hide the view window when a draw pad is minimized
*/
void HideViewWindow( HWND hwnd )
{
img_node *node;
node = SelectImage( hwnd );
if( node == NULL ) {
return;
}
ShowWindow( _wpi_getframe( node->viewhwnd ), SW_HIDE );
} /* HideViewWindow */
/*
* TransferImage - transfer the image in the outlined box to the view window
*/
void TransferImage( HWND hwnd )
{
POINT topleft_desk;
HDC hdc;
HDC memdc;
HBITMAP oldbitmap;
img_node *node;
#ifdef __NT__
SetDeskTopHook( NULL );
#endif
redrawPrevRegion();
GetCursorPos( &topleft_desk );
node = SelectImage( hwnd );
hdc = GetDC( NULL );
memdc = CreateCompatibleDC( hdc );
oldbitmap = SelectObject( memdc, node->handbitmap );
PatBlt( memdc, topLeft.x, topLeft.y, snapWidth, snapHeight, BLACKNESS );
SelectObject( memdc, node->hxorbitmap );
BitBlt( memdc, topLeft.x, topLeft.y, snapWidth, snapHeight, hdc,
topleft_desk.x, topleft_desk.y, SRCCOPY );
ReleaseDC( NULL, hdc );
SelectObject( memdc, oldbitmap );
DeleteDC( memdc );
ReleaseCapture();
ShowWindow( HMainWindow, previousState );
#ifdef __NT__
DestroyWindow( deskTopWindow );
#else
InvalidateRect( node->viewhwnd, NULL, FALSE );
#endif
RecordImage( hwnd );
SetToolType( prevToolType );
if( !DoKeepRect() ) {
SetRectExists( FALSE );
} else {
SetRectExists( rectExists );
}
#ifndef __NT__
BlowupImage( node->hwnd, NULL );
#endif
SetCursor( prevCursor );
PrintHintTextByID( WIE_BMPSNAPPEDFROMDSKTOP, NULL );
} /* TransferImage */
void nuiCoverFlow::DelImage(nuiTexture* pTexture)
{
for (int32 i = 0; i < mImages.size(); i++)
{
if (mImages[i] == pTexture)
{
mImages[i]->Release();
mImages.erase(mImages.begin() + i);
Invalidate();
SelectImage(mSelectedImage);
return;
}
}
}
/*
* RedrawPrevClip - redraw the area if a region has been selected and copied to the
* clipboard OR if a region has been selected and then another is
* selected (without a cut or copy in between)
* - the hwnd parameter indicates which window to draw the clip rect on
* - if the hwnd does not match the one associated with clipRect, we return
*/
void RedrawPrevClip( HWND hwnd )
{
WPI_POINT pointsize;
int prevROP2;
HBRUSH blackbrush;
HBRUSH oldbrush;
HPEN whitepen;
HPEN oldpen;
WPI_PRES pres;
WPI_RECTDIM left;
WPI_RECTDIM top;
WPI_RECTDIM right;
WPI_RECTDIM bottom;
img_node *node;
if( !fEnableCutCopy || !_wpi_iswindow( Instance, hwnd ) || clipRect.hwnd != hwnd ) {
return;
}
pointsize = GetPointSize( hwnd );
pres = _wpi_getpres( hwnd );
_wpi_torgbmode( pres );
prevROP2 = _wpi_setrop2( pres, R2_XORPEN );
blackbrush = _wpi_createsolidbrush( BLACK );
oldbrush = _wpi_selectobject( pres, blackbrush );
whitepen = _wpi_createpen( PS_SOLID, 0, WHITE );
oldpen = _wpi_selectobject( pres, whitepen );
_wpi_getrectvalues( clipRect.rect, &left, &top, &right, &bottom );
node = SelectImage( hwnd );
#ifdef __OS2_PM__
_wpi_rectangle( pres, left * pointsize.x + 1, bottom * pointsize.y + 1,
right * pointsize.x, top * pointsize.y );
#else
_wpi_rectangle( pres, left * pointsize.x, top * pointsize.y,
right * pointsize.x, bottom * pointsize.y );
#endif
_wpi_selectobject( pres, oldpen );
_wpi_selectobject( pres, oldbrush );
_wpi_setrop2( pres, prevROP2 );
_wpi_releasepres( hwnd, pres );
_wpi_deleteobject( whitepen );
_wpi_deleteobject( blackbrush );
} /* RedrawPrevClip */
long CCdromSelectionWnd::OnCommand(unsigned short nID, unsigned short nCmd, HWND hFrom)
{
if(hFrom == m_pOk->m_hWnd)
{
if(m_nType == BINDING_IMAGE)
{
if(m_sImagePath.length() == 0)
{
MessageBox(m_hWnd, _T("Please select a disk image to bind with this device."), NULL, 16);
return FALSE;
}
}
m_nConfirmed = true;
Destroy();
return FALSE;
}
if(hFrom == m_pCancel->m_hWnd)
{
Destroy();
return FALSE;
}
if(hFrom == m_pImageRadio->m_hWnd)
{
m_nType = BINDING_IMAGE;
UpdateControls();
}
if(hFrom == m_pImageBrowse->m_hWnd)
{
SelectImage();
UpdateControls();
}
if(hFrom == m_pDeviceRadio->m_hWnd)
{
m_nType = BINDING_PHYSICAL;
m_nPhysicalDevice = m_pDeviceCombo->GetItemData(m_pDeviceCombo->GetSelection());
UpdateControls();
}
if(hFrom == m_pDeviceCombo->m_hWnd)
{
if(nCmd == CBN_SELCHANGE)
{
m_nPhysicalDevice = m_pDeviceCombo->GetItemData(m_pDeviceCombo->GetSelection());
UpdateControls();
}
}
return TRUE;
}
/*
* FocusOnImage - Selects one of the mdi children.
*/
void FocusOnImage( HWND hwnd )
{
char current_file[ _MAX_PATH ];
char *text;
if (activeImage) {
RedrawPrevClip(activeImage->hwnd);
SetRectExists( FALSE );
}
activeImage = SelectImage( hwnd );
if (!activeImage) {
WImgEditError( WIE_ERR_BAD_HWND, WIE_INTERNAL_001 );
return;
}
ResetViewWindow( activeImage->viewhwnd );
CreateDrawnImage( activeImage );
SetMenus( activeImage );
SetNumColours( 1<<(activeImage->bitcount) );
SetHotSpot( activeImage );
DisplayImageText( activeImage );
CheckForUndo( activeImage );
GetFnameFromPath( activeImage->fname, current_file );
text = (char *)
MemAlloc( strlen( IEAppTitle ) + strlen( current_file ) + 3 + 1 );
if( text ) {
strcpy( text, IEAppTitle );
strcat( text, " - " );
strcat( text, current_file );
_wpi_setwindowtext( _wpi_getframe(HMainWindow), text );
MemFree( text );
}
#ifndef __OS2_PM__
RedrawWindow( hwnd, NULL, NULL, RDW_UPDATENOW );
#endif
} /* FocusOnImage */
void CGLWorkspace::mousePressEvent(QMouseEvent *event){
iActiveImage = NULL;
QListIterator<CGLImage*> images(iImages);
images.toBack ();
while (images.hasPrevious())
{
CGLImage* obj = images.previous();
if(obj->IsPointOnObject(event->x(),event->y()))
{
iActiveImage = obj;
iImages.move(iImages.indexOf(obj),iImages.count()-1);
obj->mousePressEvent(event);
SelectImage(obj);
UpdateTexture();
//updateGL ();
break;
}
}
CInfoPanel::GetInstance()->SetWorkspaceInfoView();
}
/*
* AbortSnap - abort the snapping of an image
*/
void AbortSnap( HWND hwnd )
{
img_node *node;
#ifdef __NT__
SetDeskTopHook( NULL );
#endif
node = SelectImage( hwnd );
ReleaseCapture();
ShowWindow( HMainWindow, previousState );
#ifdef __NT__
DestroyWindow( deskTopWindow );
#else
InvalidateRect( node->viewhwnd, NULL, FALSE );
#endif
SetToolType( prevToolType );
SetCursor( prevCursor );
PrintHintTextByID( WIE_BMPSNAPABORTED, NULL );
} /* AbortSnap */
void CImageExplorer::mousePressEvent(QMouseEvent *event)
{
iActiveImage = NULL;
QListIterator<CImage*> images(iImages);
images.toBack ();
while (images.hasPrevious())
{
CImage* obj = images.previous();
if(obj->IsPointOnObject(event->x(),event->y()))
{
//iActiveImage = obj;
//iImages.move(iImages.indexOf(obj),iImages.count()-1);
obj->mousePressEvent(event);
SelectImage(obj);
CWidget::GetInstance()->paint();
break;
}
}
if(CInfoPanel::GetInstance())
{
CInfoPanel::GetInstance()->SetImageExplorerInfoView();
}
}
/*
* DrawAreaWinProc - window procedure for the drawing area window
* - this window is an MDI window
*/
MRESULT CALLBACK DrawAreaWinProc( HWND hwnd, WPI_MSG msg,
WPI_PARAM1 wparam, WPI_PARAM2 lparam )
{
static WPI_POINT start_pt = { -1, -1 };
static WPI_POINT end_pt = { -1, -1 };
static WPI_POINT prev_pt = { -1, -1 };
static WPI_POINT new_pt = { -1, -1 };
static WPI_POINT pt1;
static BOOL flbuttondown = FALSE;
static BOOL frbuttondown = FALSE;
static BOOL fdraw_shape = FALSE;
static BOOL firsttime;
static BOOL wasicon;
int mousebutton;
WPI_POINT pointsize;
WPI_POINT pt2;
#ifndef __OS2_PM__
CREATESTRUCT *cs;
MDICREATESTRUCT *mdi_cs;
MINMAXINFO *minmax;
#endif
img_node *node;
int i;
switch ( msg ) {
case WM_CREATE:
#ifndef __OS2_PM__
cs = (CREATESTRUCT __FAR *)lparam;
mdi_cs = (MDICREATESTRUCT __FAR *)cs->lpCreateParams;
node = (img_node *)mdi_cs->lParam;
for( i = 0; i < node->num_of_images; i++ ) {
node[i].hwnd = hwnd;
}
AddImageNode( node );
CreateUndoStack( node );
setTheCursor( -1, hwnd );
wasicon = FALSE;
#endif
firsttime = TRUE;
i = i;
return( 0 );
case WM_MDIACTIVATE:
if( IMGED_GET_MDI_FACTIVATE( hwnd, wparam, lparam ) ) {
if( _wpi_isiconic( hwnd ) ) {
wasicon = TRUE;
break;
} else {
wasicon = FALSE;
FocusOnImage( hwnd );
}
}
return( 0 );
#ifndef __OS2_PM__
case WM_GETMINMAXINFO:
node = SelectImage( hwnd );
if( node != NULL ) {
minmax = (MINMAXINFO *)lparam;
minmax->ptMinTrackSize.x = node->width +
2 * _wpi_getsystemmetrics( SM_CXFRAME );
minmax->ptMinTrackSize.y = node->height +
2 * _wpi_getsystemmetrics( SM_CYFRAME ) +
_wpi_getsystemmetrics( SM_CYCAPTION ) - 1;
}
break;
#endif
case UM_SHOWVIEWWINDOW:
ShowViewWindows( hwnd );
return 0;
case WM_SIZE:
if ( _imgwpi_issizerestored( wparam ) ) {
ResizeChild( lparam, hwnd, firsttime );
firsttime = FALSE;
if( wasicon ) {
FocusOnImage( hwnd );
wasicon = FALSE;
}
#ifndef __OS2_PM__
} else if ( _imgwpi_issizeminimized( wparam ) ) {
node = SelectImage( hwnd );
HideViewWindow( hwnd );
DeleteActiveImage();
ClearImageText();
SendMessage( ClientWindow, WM_MDINEXT, (WPARAM)(LPVOID)hwnd, 0L );
wasicon = TRUE;
#endif
}
return( 0 );
#ifndef __OS2_PM__
case WM_CHAR:
pointsize = GetPointSize( hwnd );
if( LOWORD( wparam ) == ESC_CHAR ) {
if( !(lparam & 0x40000000) ) {
switch( toolType ) {
case IMGED_PASTE:
fdraw_shape = FALSE;
flbuttondown = FALSE;
frbuttondown = FALSE;
DontPaste( hwnd, &pt1, pointsize );
break;
case IMGED_LINE:
case IMGED_RECTO:
case IMGED_RECTF:
case IMGED_CIRCLEO:
case IMGED_CIRCLEF:
case IMGED_CLIP:
if( !flbuttondown && !frbuttondown ) {
break;
}
fdraw_shape = FALSE;
flbuttondown = FALSE;
frbuttondown = FALSE;
if( toolType == IMGED_LINE ) {
OutlineLine( hwnd, &start_pt, &prev_pt, &new_pt, TRUE );
} else if( toolType == IMGED_CLIP ) {
OutlineClip( hwnd, &start_pt, &prev_pt, &new_pt, TRUE );
SetRectExists( FALSE );
} else {
OutlineRegion( hwnd, &start_pt, &prev_pt, &new_pt, TRUE );
}
break;
default:
break;
}
}
}
return( 0 );
#endif
case WM_MOUSEMOVE:
pointsize = GetPointSize( hwnd );
#ifdef __OS2_PM__
WinSetPointer( HWND_DESKTOP, hCursor[cursorIndex] );
#endif
IMGED_MAKEPOINT( wparam, lparam, new_pt );
switch( toolType ) {
case IMGED_SNAP:
#ifndef __OS2_PM__
OutlineSnap();
#endif
break;
case IMGED_PASTE:
pt1.x = new_pt.x / pointsize.x;
pt1.y = new_pt.y / pointsize.y;
pt2.x = prev_pt.x / pointsize.x;
pt2.y = prev_pt.y / pointsize.y;
if( pt1.x != pt2.x || pt1.y != pt2.y ) {
DragClipBitmap( hwnd, &pt1, pointsize );
}
SetPosInStatus( &new_pt, &pointsize, hwnd );
break;
case IMGED_FREEHAND:
case IMGED_BRUSH:
if( flbuttondown ) {
Paint( hwnd, &prev_pt, &new_pt, LMOUSEBUTTON );
} else if( frbuttondown ) {
Paint( hwnd, &prev_pt, &new_pt, RMOUSEBUTTON );
}
SetPosInStatus( &new_pt, &pointsize, hwnd );
break;
case IMGED_LINE:
case IMGED_RECTO:
case IMGED_RECTF:
case IMGED_CIRCLEO:
case IMGED_CIRCLEF:
case IMGED_CLIP:
if( flbuttondown || frbuttondown ) {
if( new_pt.x / pointsize.x != end_pt.x / pointsize.x ||
new_pt.y / pointsize.y != end_pt.y / pointsize.y ) {
if( toolType == IMGED_LINE ) {
OutlineLine( hwnd, &start_pt, &new_pt, &prev_pt, FALSE );
} else if( toolType == IMGED_CLIP ) {
OutlineClip( hwnd, &start_pt, &new_pt, &prev_pt, FALSE );
} else {
OutlineRegion( hwnd, &start_pt, &new_pt, &prev_pt, FALSE );
}
end_pt = new_pt;
SetSizeInStatus( hwnd, &start_pt, &new_pt, &pointsize );
}
} else {
SetPosInStatus( &new_pt, &pointsize, hwnd );
}
break;
case IMGED_FILL:
SetPosInStatus( &new_pt, &pointsize, hwnd );
break;
default:
SetPosInStatus( &new_pt, &pointsize, hwnd );
break;
}
prev_pt = new_pt;
return( 0 );
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
pointsize = GetPointSize( hwnd );
SetCapture( hwnd );
if( msg == WM_LBUTTONDOWN ) {
if( frbuttondown ) {
break;
}
#ifdef __OS2_PM__
node = GetCurrentNode();
if( hwnd != node->hwnd ) {
break;
}
#endif
flbuttondown = TRUE;
mousebutton = LMOUSEBUTTON;
} else {
if( flbuttondown ) {
break;
}
node = GetCurrentNode();
if( hwnd != node->hwnd ) {
break;
}
frbuttondown = TRUE;
mousebutton = RMOUSEBUTTON;
}
fdraw_shape = TRUE;
IMGED_MAKEPOINT( wparam, lparam, start_pt );
IMGED_MAKEPOINT( wparam, lparam, new_pt );
switch( toolType ) {
case IMGED_SNAP:
#ifndef __OS2_PM__
TransferImage( hwnd );
#endif
fdraw_shape = FALSE;
flbuttondown = FALSE;
frbuttondown = FALSE;
break;
case IMGED_FREEHAND:
case IMGED_BRUSH:
BeginFreeHand( hwnd );
DrawSinglePoint( hwnd, &start_pt, mousebutton );
break;
case IMGED_LINE:
IMGED_MAKEPOINT( wparam, lparam, end_pt );
OutlineLine( hwnd, &start_pt, &new_pt, &prev_pt, TRUE );
break;
case IMGED_RECTO:
case IMGED_RECTF:
case IMGED_CIRCLEO:
case IMGED_CIRCLEF:
IMGED_MAKEPOINT( wparam, lparam, end_pt );
OutlineRegion( hwnd, &start_pt, &new_pt, &prev_pt, TRUE );
break;
case IMGED_CLIP:
IMGED_MAKEPOINT( wparam, lparam, end_pt );
RedrawPrevClip( hwnd );
OutlineClip( hwnd, &start_pt, &new_pt, &prev_pt, TRUE );
break;
case IMGED_FILL:
FillArea( &start_pt, mousebutton );
RecordImage( hwnd );
break;
case IMGED_HOTSPOT:
SetIsSaved( hwnd, FALSE );
prev_pt.x = start_pt.x / pointsize.x;
prev_pt.y = start_pt.y / pointsize.y;
SetNewHotSpot( &prev_pt );
break;
default:
break;
}
prev_pt = new_pt;
return 0;
case WM_LBUTTONUP:
case WM_RBUTTONUP:
pointsize = GetPointSize( hwnd );
IMGED_MAKEPOINT( wparam, lparam, end_pt );
IMGED_MAKEPOINT( wparam, lparam, new_pt );
if( msg == WM_LBUTTONUP ) {
mousebutton = LMOUSEBUTTON;
} else {
mousebutton = RMOUSEBUTTON;
}
if( fdraw_shape ) {
switch( toolType ) {
case IMGED_PASTE:
PasteImage( &start_pt, pointsize, hwnd );
flbuttondown = FALSE;
frbuttondown = FALSE;
break;
case IMGED_FREEHAND:
case IMGED_BRUSH:
if( flbuttondown || frbuttondown ) {
EndFreeHand( hwnd );
RecordImage( hwnd );
}
break;
case IMGED_LINE:
DrawLine( hwnd, &start_pt, &end_pt, mousebutton );
RecordImage( hwnd );
break;
case IMGED_RECTO:
case IMGED_RECTF:
case IMGED_CIRCLEO:
case IMGED_CIRCLEF:
DisplayRegion( hwnd, &start_pt, &end_pt, mousebutton );
RecordImage( hwnd );
break;
case IMGED_CLIP:
SetClipRect( hwnd, &start_pt, &end_pt, pointsize );
break;
default:
break;
}
fdraw_shape = FALSE;
}
ReleaseCapture();
flbuttondown = FALSE;
frbuttondown = FALSE;
prev_pt = new_pt;
return( 0 );
case WM_PAINT:
RepaintDrawArea( hwnd );
return( 0 );
case WM_QUERYENDSESSION:
case WM_CLOSE:
if( lastChanceSave( hwnd ) ) {
CloseCurrentImage( hwnd );
return( (MRESULT)1 );
} else {
return( (MRESULT)0 );
}
#ifndef __OS2_PM__
case WM_DESTROY:
SetCursor( LoadCursor( NULL, IDC_ARROW ) );
return( 0 );
#endif
default:
break;
}
return( _imgwpi_defMDIchildproc( hwnd, msg, wparam, lparam ) );
} /* DrawAreaWinProc */
/*
* PasteImage - paste the image in the clipboard at the current point
* - first check to see if the image was cut/copied from our program
* - if it was, then we use the hXorClipped and hAndClipped bitmaps
* we created in order to preserve the screen colors if ther were used
* - otherwise, just copy from the clipboard
*/
void PasteImage( WPI_POINT *pt, WPI_POINT pointsize, HWND hwnd )
{
HBITMAP hbitmap;
HBITMAP hbitmapdup;
HBITMAP holddup;
HBITMAP oldbitmap;
HBITMAP oldbitmap2;
WPI_PRES pres;
WPI_PRES mempres;
HDC memdc;
WPI_PRES clippres;
HDC clipdc;
WPI_RECT client;
WPI_POINT truept;
short width;
short height;
short clipwidth;
short clipheight;
img_node *node;
int fstretchbmp;
int bm_width, bm_height;
WPI_RECTDIM left;
WPI_RECTDIM right;
WPI_RECTDIM top;
WPI_RECTDIM bottom;
WPI_RECTDIM client_l;
WPI_RECTDIM client_r;
WPI_RECTDIM client_t;
WPI_RECTDIM client_b;
#ifdef __OS2_PM__
int src_y, dest_y;
#endif
if( fEnableCutCopy ) {
_wpi_getwrectvalues( clipRect.rect, &left, &top, &right, &bottom );
truept.x = left;
truept.y = top;
fstretchbmp = StretchPastedImage();
} else {
truept.x = pt->x / pointsize.x;
truept.y = pt->y / pointsize.y;
fstretchbmp = -1;
}
node = SelectImage( hwnd );
pres = _wpi_getpres( node->viewhwnd );
if( _wpi_getclipboardowner( Instance ) == HMainWindow && node->imgtype != BITMAP_IMG ) {
_wpi_getbitmapdim( hAndClipped, &bm_width, &bm_height );
GetClientRect( node->hwnd, &client );
if( fEnableCutCopy ) {
width = (short)_wpi_getwidthrect( clipRect.rect );
height = (short)_wpi_getheightrect( clipRect.rect );
} else {
_wpi_getrectvalues( client, &client_l, &client_t, &client_r, &client_b );
width = (short)( client_r / pointsize.x - truept.x );
if( width > (short)bm_width )
width = (short)bm_width;
height = (short)( client_b / pointsize.y - truept.y );
if( height > (short)bm_height ) {
height = (short)bm_height;
}
}
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_setstretchbltmode( mempres, COLORONCOLOR );
clippres = _wpi_createcompatiblepres( pres, Instance, &clipdc );
oldbitmap = _wpi_selectbitmap( mempres, node->handbitmap );
oldbitmap2 = _wpi_selectbitmap( clippres, hAndClipped );
if( fstretchbmp == FALSE ) {
clipwidth = (short)bm_width;
if( clipwidth > (short)width )
clipwidth = (short)width;
clipheight = (short)bm_height;
if( clipheight > (short)height )
clipheight = (short)height;
_wpi_patblt( mempres, truept.x, truept.y, width, height, BLACKNESS );
_wpi_bitblt( mempres, truept.x, truept.y, clipwidth, clipheight,
clippres, 0, 0, SRCCOPY );
} else if( fstretchbmp == TRUE ) {
_wpi_stretchblt( mempres, truept.x, truept.y, width, height,
clippres, 0, 0, bm_width, bm_height, SRCCOPY);
} else {
_wpi_bitblt( mempres, truept.x, truept.y, width, height, clippres,
0, 0, SRCCOPY );
}
_wpi_getoldbitmap( mempres, oldbitmap );
oldbitmap = _wpi_selectbitmap( mempres, node->hxorbitmap );
hbitmapdup = DuplicateBitmap( hXorClipped );
_wpi_getoldbitmap( clippres, oldbitmap2 );
oldbitmap2 = _wpi_selectbitmap( clippres, hbitmapdup );
if( fstretchbmp == FALSE ) {
clipwidth = (short)bm_width;
if( clipwidth > (short)width )
clipwidth = (short)width;
clipheight = (short)bm_height;
if( clipheight > (short)height )
clipheight = (short)height;
_wpi_patblt( mempres, truept.x, truept.y, width, height, WHITENESS );
#ifdef __OS2_PM__
if( bm_height > height ) {
src_y = bm_height - height;
dest_y = truept.y;
} else {
src_y = 0;
dest_y = truept.y + (height - bm_height);
}
_wpi_bitblt( mempres, truept.x, dest_y, clipwidth, clipheight,
clippres, 0, src_y, SRCCOPY );
#else
_wpi_bitblt( mempres, truept.x, truept.y, clipwidth, clipheight,
clippres, 0, 0, SRCCOPY );
#endif
} else if( fstretchbmp == TRUE ) {
_wpi_stretchblt( mempres, truept.x, truept.y, width, height,
clippres, 0, 0, bm_width, bm_height, SRCCOPY );
} else {
_wpi_bitblt( mempres, truept.x, truept.y, width, height, clippres,
0, 0, SRCCOPY );
}
_wpi_getoldbitmap( mempres, oldbitmap );
_wpi_getoldbitmap( clippres, oldbitmap2 );
_wpi_deletebitmap( hbitmapdup );
_wpi_deletecompatiblepres( mempres, memdc );
_wpi_deletecompatiblepres( clippres, clipdc );
} else {
if( node->imgtype != BITMAP_IMG ) {
CleanupClipboard();
}
_wpi_openclipboard( Instance, HMainWindow );
hbitmap = _wpi_getclipboarddata( Instance, CF_BITMAP );
hbitmapdup = DuplicateBitmap( hbitmap );
_wpi_closeclipboard( Instance );
_wpi_getbitmapdim( hbitmapdup, &bm_width, &bm_height );
GetClientRect( node->hwnd, &client );
if( fEnableCutCopy ) {
width = (short)_wpi_getwidthrect( clipRect.rect );
height = (short)_wpi_getheightrect( clipRect.rect );
} else {
_wpi_getrectvalues( client, &client_l, &client_t, &client_r, &client_b );
width = (short)( client_r / pointsize.x - truept.x );
if( width > (short)bm_width )
width = (short)bm_width;
height = (short)( client_b / pointsize.y - truept.y );
if( height > (short)bm_height ) {
height = (short)bm_height;
}
}
clippres = _wpi_createcompatiblepres( pres, Instance, &clipdc );
mempres = _wpi_createcompatiblepres( pres, Instance, &memdc );
_wpi_setstretchbltmode( mempres, COLORONCOLOR );
holddup = _wpi_selectbitmap( clippres, hbitmapdup );
oldbitmap = _wpi_selectbitmap( mempres, node->hxorbitmap );
if( fstretchbmp == FALSE ) {
clipwidth = (short)bm_width;
if( clipwidth > (short)width )
clipwidth = (short)width;
clipheight = (short)bm_height;
if( clipheight > (short)height )
clipheight = (short)height;
_wpi_patblt( mempres, truept.x, truept.y, width, height, WHITENESS );
#ifdef __OS2_PM__
if( bm_height > height ) {
src_y = bm_height - height;
dest_y = truept.y;
} else {
src_y = 0;
dest_y = truept.y + (height - bm_height);
}
_wpi_bitblt( mempres, truept.x, dest_y, clipwidth, clipheight,
clippres, 0, src_y, SRCCOPY );
#else
_wpi_bitblt( mempres, truept.x, truept.y, clipwidth, clipheight,
clippres, 0, 0, SRCCOPY );
#endif
} else if( fstretchbmp == TRUE ) {
_wpi_stretchblt( mempres, truept.x, truept.y, width, height,
clippres, 0, 0, bm_width, bm_height, SRCCOPY );
} else {
_wpi_bitblt( mempres, truept.x, truept.y, width, height, clippres,
0, 0, SRCCOPY );
}
_wpi_getoldbitmap( clippres, holddup );
_wpi_deletebitmap( hbitmapdup );
_wpi_deletecompatiblepres( clippres, clipdc );
_wpi_getoldbitmap( mempres, oldbitmap );
oldbitmap = _wpi_selectbitmap( mempres, node->handbitmap );
_wpi_patblt( mempres, truept.x, truept.y, width, height, BLACKNESS );
_wpi_getoldbitmap( mempres, oldbitmap );
_wpi_deletecompatiblepres( mempres, memdc );
}
ReleaseCapture();
_wpi_releasepres( node->viewhwnd, pres );
InvalidateRect( node->viewhwnd, NULL, TRUE );
if( !fEnableCutCopy ) {
_wpi_setcursor( prevCursor );
_wpi_destroycursor( pointCursor );
SetToolType( prevToolType );
}
fEnableCutCopy = FALSE;
RecordImage( hwnd );
BlowupImage( NULL, NULL );
PrintHintTextByID( WIE_BITMAPPASTED, NULL );
} /* PasteImage */
/*
* showGrid - Display the grid on the draw area.
*/
static void showGrid( HWND hwnd, WPI_PRES mempres )
{
short i;
short psx;
short psy;
WPI_RECT rcclient;
HPEN hblackpen;
HPEN holdpen;
img_node *node;
short width;
short height;
IMGED_DIM left;
IMGED_DIM right;
IMGED_DIM top;
IMGED_DIM bottom;
WPI_PRES pres;
WPI_POINT startpt;
WPI_POINT endpt;
node = SelectImage( hwnd );
_wpi_torgbmode( mempres );
GetClientRect( hwnd, &rcclient );
width = (short)( _wpi_getwidthrect(rcclient) );
height = (short)( _wpi_getheightrect(rcclient) );
if (((width / node->width) < POINTSIZE_MIN) ||
((height / node->height) < POINTSIZE_MIN)) {
psx = 0;
psy = 0;
} else {
psx = width / node->width;
psy = height / node->height;
hblackpen = _wpi_createpen( PS_SOLID, 0, BLACK );
holdpen = _wpi_selectobject( mempres, hblackpen );
_wpi_getrectvalues( rcclient, &left, &top, &right, &bottom );
for (i=0; i < width; i = i + psx) {
_wpi_setpoint( &startpt, i, top );
_wpi_setpoint( &endpt, i, bottom );
_wpi_movetoex( mempres, &startpt, NULL );
_wpi_lineto( mempres, &endpt );
}
for (i=0; i <= height; i = i + psy) {
_wpi_setpoint( &startpt, left, i );
_wpi_setpoint( &endpt, right, i );
_wpi_movetoex( mempres, &startpt, NULL );
_wpi_lineto( mempres, &endpt );
}
_wpi_selectobject( mempres, holdpen );
_wpi_deleteobject( hblackpen );
}
pres = _wpi_getpres( hwnd );
_wpi_bitblt( pres, 0, 0, width, height, mempres, 0, 0, SRCCOPY );
_wpi_releasepres( hwnd, pres );
RedrawPrevClip(hwnd); // Redraws if there was a clip region specified.
} /* showGrid */
/*
* ResizeChild - resizes the draw area of the child window.
*/
void ResizeChild( WPI_PARAM2 lparam, HWND hwnd, BOOL firsttime )
{
short min_width;
short width;
short height;
img_node *node;
short x_adjustment;
short y_adjustment;
short new_width;
short new_height;
WPI_POINT point_size;
WPI_POINT max;
HWND frame;
HMENU hmenu;
WPI_RECT rc;
WPI_RECT rect;
frame = _wpi_getframe( hwnd );
width = LOWORD( lparam );
#ifdef __OS2_PM__
height = SHORT2FROMMP( lparam );
#else
height = HIWORD( lparam );
#endif
GetClientRect( hwnd, &rc );
GetWindowRect( hwnd, &rect );
if( frame ) {
GetClientRect( frame, &rc );
GetWindowRect( frame, &rect );
}
max.x = _wpi_getsystemmetrics( SM_CXSCREEN );
max.y = _wpi_getsystemmetrics( SM_CYSCREEN );
x_adjustment = _wpi_getwidthrect( rect ) - _wpi_getwidthrect( rc );
y_adjustment = _wpi_getheightrect( rect ) - _wpi_getheightrect( rc );
#if 1
min_width = MIN_DRAW_WIN_WIDTH;
#else
min_width = (short)(2*_wpi_getsystemmetrics(SM_CXSIZE)) +
x_adjustment +
8; // fudge factor to allow some of title bar to show
#endif
#ifdef __OS2_PM__
++y_adjustment;
#endif
node = SelectImage( hwnd );
if (!node) return;
// the following assumes that max.x >> min_width
point_size.x = min( max.x / node->width, width / node->width );
point_size.x = max( min_width / node->width + 1, point_size.x );
point_size.y = min( max.y / node->height, height / node->height );
point_size.y = max( 1, point_size.y );
if( ImgedConfigInfo.square_grid ) {
point_size.x = min( point_size.x, point_size.y );
if( point_size.x < ( min_width / node->width + 1 ) ) {
point_size.x = min_width / node->width + 1;
}
if( point_size.x > ( max.y / node->height ) ) {
hmenu = GetMenu( _wpi_getframe(HMainWindow) );
CheckSquareGrid( hmenu );
} else {
point_size.y = point_size.x;
}
}
new_width = (short)(point_size.x * node->width + x_adjustment);
new_height = (short)(point_size.y * node->height + y_adjustment);
pointSize = point_size;
if( (pointSize.x*node->width != width) ||
(pointSize.y*node->height != height) ) {
SetWindowPos( frame, HWND_TOP, 0, 0, new_width, new_height,
SWP_SIZE | SWP_ZORDER | SWP_NOMOVE | SWP_SHOWWINDOW);
SetGridSize( pointSize.x, pointSize.y );
}
if( !firsttime ) {
BlowupImage( node->hwnd, NULL );
}
} /* ResizeChild */
/*
* lastChanceSave - called when the user quits and the current image
* is not yet saved
* - return FALSE if CANCEL is selected
* - otherwise, it return TRUE
*/
static BOOL lastChanceSave( HWND hwnd )
{
int retcode;
int how;
HMENU hmenu;
img_node *node;
img_node *icon;
char *title;
char *text;
char *msg_text;
char filename[_MAX_PATH];
if( !DoImagesExist() ) {
return( TRUE );
}
node = SelectImage( hwnd );
if( node == NULL ) {
return( TRUE );
}
icon = GetImageNode( hwnd );
while( icon != NULL ) {
if( icon->issaved ) {
return( TRUE );
}
icon = icon->nexticon;
}
if( strnicmp( node->fname, IEImageUntitled, strlen( IEImageUntitled ) ) != 0 ) {
GetFnameFromPath( node->fname, filename );
how = SB_SAVE;
} else {
strcpy( filename, node->fname );
how = SB_SAVE_AS;
}
retcode = WPI_IDCANCEL;
title = IEAllocRCString( WIE_CLOSETITLE );
text = IEAllocRCString( WIE_QUERYIMAGESAVE );
if( text != NULL ) {
msg_text = (char *)MemAlloc( strlen( text ) + strlen( filename ) + 1 );
if( msg_text != NULL ) {
sprintf( msg_text, text, filename );
retcode = _wpi_messagebox( HMainWindow, msg_text, title,
MB_YESNOCANCEL | MB_ICONQUESTION );
MemFree( msg_text );
}
IEFreeRCString( text );
}
if( title != NULL ) {
IEFreeRCString( title );
}
if( retcode == WPI_IDYES ) {
if( !SaveFile( how ) ) {
PrintHintTextByID( WIE_FILENOTSAVED, NULL );
return( FALSE );
} else {
hmenu = _wpi_getmenu( _wpi_getframe( HMainWindow ) );
_wpi_enablemenuitem( hmenu, IMGED_SAVE, FALSE, FALSE );
SetIsSaved( hwnd, TRUE );
}
} else if( retcode == WPI_IDCANCEL ) {
return( FALSE );
}
return( TRUE );
} /* lastChanceSave */
/*
* EnlargeImage - take an MDI window handle and enlarge the view bitmap
* that goes with it
* - returns a handle to the bitmap
* - the bitmap must be deleted by the calling routine
*/
HBITMAP EnlargeImage( HWND hwnd )
{
WPI_PRES pres;
WPI_PRES srcpres;
WPI_PRES destpres;
HDC srcdc;
HDC destdc;
HBITMAP oldbitmap;
HBITMAP newbitmap;
HBITMAP olddestbitmap;
HBITMAP viewbitmap;
img_node *node;
WPI_RECT rc;
short width;
short height;
int window_width;
int window_height;
BITMAP bm;
node = SelectImage( hwnd );
if( node == NULL ) {
return( NULL );
}
viewbitmap = CreateViewBitmap( node );
_wpi_getclientrect( hwnd, &rc );
/*
* I add this so that if the window's client rect doesn't fit on the
* screen, it will still enlarge to the right size.
*/
window_width = _wpi_getwidthrect( rc );
window_height = _wpi_getheightrect( rc );
if( window_width < node->width ) {
window_width = node->width;
}
if( window_height < node->height ) {
window_height = node->height;
}
pres = _wpi_getpres( HWND_DESKTOP );
srcpres = _wpi_createcompatiblepres( pres, Instance, &srcdc );
destpres = _wpi_createcompatiblepres( pres, Instance, &destdc );
newbitmap = _wpi_createcompatiblebitmap( pres, _wpi_getwidthrect( rc ),
_wpi_getheightrect( rc ) );
_wpi_releasepres( HWND_DESKTOP, pres );
GetObject( newbitmap, sizeof( BITMAP ), &bm );
_wpi_torgbmode( destpres );
_wpi_torgbmode( srcpres );
olddestbitmap = _wpi_selectobject( destpres, newbitmap );
oldbitmap = _wpi_selectobject( srcpres, viewbitmap );
height = node->height;
width = node->width;
IEStretchBlt( destpres, 0, 0, _wpi_getwidthrect( rc ),
_wpi_getheightrect( rc ), srcpres, 0, 0, width, height,
SRCCOPY, bm.bmBitsPixel );
_wpi_selectobject( srcpres, oldbitmap );
_wpi_deletecompatiblepres( srcpres, srcdc );
_wpi_deleteobject( viewbitmap );
_wpi_selectobject( destpres, olddestbitmap );
_wpi_deletecompatiblepres( destpres, destdc );
return( newbitmap );
} /* EnlargeImage */
void nuiCoverFlow::SelectImageIndex(int32 index)
{
SelectImage(index);
}
