1449 lines
34 KiB
C++
1449 lines
34 KiB
C++
//
|
||
// BitmapObj.CPP
|
||
// Bitmap objects:
|
||
//
|
||
// Copyright Microsoft 1998-
|
||
//
|
||
#include "precomp.h"
|
||
|
||
#include "NMWbObj.h"
|
||
|
||
BitmapObj::BitmapObj (BitmapCreatePDU * pbitmapCreatePDU)
|
||
{
|
||
ResetAttrib();
|
||
SetType(bitmapCreatePDU_chosen);
|
||
SetPenThickness(0);
|
||
SetMyWorkspace(NULL);
|
||
m_lpTransparencyMask = NULL;
|
||
m_lpbiImage = NULL;
|
||
m_lpBitMask = NULL;
|
||
m_hSaveBitmap = NULL;
|
||
m_hOldBitmap = NULL;
|
||
m_hIcon = NULL;
|
||
m_fMoreToFollow = TRUE;
|
||
|
||
//
|
||
// Created remotely, not selected, not editing or deleting.
|
||
//
|
||
ClearCreationFlags();
|
||
ClearSelectionFlags();
|
||
ClearEditionFlags();
|
||
ClearDeletionFlags();
|
||
|
||
if(pbitmapCreatePDU->bitmapFormatHeader.choice != bitmapHeaderNonStandard_chosen)
|
||
{
|
||
ERROR_OUT(("Only Handle uncompresed bitmaps"));
|
||
return;
|
||
}
|
||
|
||
SetThisObjectHandle(pbitmapCreatePDU->bitmapHandle);
|
||
|
||
UINT workspaceHandle;
|
||
UINT planeID;
|
||
m_ToolType = GetBitmapDestinationAddress(&pbitmapCreatePDU->destinationAddress, &workspaceHandle, &planeID);
|
||
SetWorkspaceHandle(workspaceHandle);
|
||
SetPlaneID(planeID);
|
||
|
||
//
|
||
// Get bitmap attributes
|
||
//
|
||
if(pbitmapCreatePDU->bit_mask & BitmapCreatePDU_attributes_present)
|
||
{
|
||
GetBitmapAttrib(pbitmapCreatePDU->attributes);
|
||
}
|
||
|
||
//
|
||
// Get bitmap anchor point
|
||
//
|
||
if(pbitmapCreatePDU->bit_mask & BitmapCreatePDU_anchorPoint_present)
|
||
{
|
||
|
||
SetAnchorPoint(pbitmapCreatePDU->anchorPoint.xCoordinate, pbitmapCreatePDU->anchorPoint.yCoordinate);
|
||
}
|
||
|
||
//
|
||
// Get bitmap size
|
||
//
|
||
m_bitmapSize.x = pbitmapCreatePDU->bitmapSize.width;
|
||
m_bitmapSize.y = pbitmapCreatePDU->bitmapSize.height;
|
||
|
||
RECT rect;
|
||
rect.top = pbitmapCreatePDU->anchorPoint.yCoordinate;
|
||
rect.left = pbitmapCreatePDU->anchorPoint.xCoordinate;
|
||
rect.bottom = pbitmapCreatePDU->anchorPoint.yCoordinate + m_bitmapSize.y;
|
||
rect.right = pbitmapCreatePDU->anchorPoint.xCoordinate + m_bitmapSize.x;
|
||
SetRect(&rect);
|
||
|
||
//
|
||
// Get bitmap region of interest
|
||
//
|
||
if(pbitmapCreatePDU->bit_mask & bitmapRegionOfInterest_present)
|
||
{
|
||
m_bitmapRegionOfInterest.left = pbitmapCreatePDU->bitmapRegionOfInterest.upperLeft.xCoordinate;
|
||
m_bitmapRegionOfInterest.top = pbitmapCreatePDU->bitmapRegionOfInterest.upperLeft.yCoordinate;
|
||
m_bitmapRegionOfInterest.right = pbitmapCreatePDU->bitmapRegionOfInterest.lowerRight.xCoordinate;
|
||
m_bitmapRegionOfInterest.bottom = pbitmapCreatePDU->bitmapRegionOfInterest.lowerRight.yCoordinate;
|
||
}
|
||
|
||
//
|
||
// Get the bitmap pixel aspect ration
|
||
//
|
||
m_pixelAspectRatio = pbitmapCreatePDU->pixelAspectRatio.choice;
|
||
|
||
if(pbitmapCreatePDU->bit_mask & BitmapCreatePDU_scaling_present)
|
||
{
|
||
m_scaling.x = pbitmapCreatePDU->scaling.xCoordinate;
|
||
m_scaling.y = pbitmapCreatePDU->scaling.yCoordinate;
|
||
}
|
||
|
||
|
||
//
|
||
// Non standard bitmap
|
||
//
|
||
if((pbitmapCreatePDU->bit_mask & BitmapCreatePDU_nonStandardParameters_present) &&
|
||
pbitmapCreatePDU->nonStandardParameters->value.nonStandardIdentifier.choice == h221nonStandard_chosen)
|
||
{
|
||
|
||
m_bitmapData.m_length = pbitmapCreatePDU->nonStandardParameters->value.data.length;
|
||
m_lpbiImage = (LPBITMAPINFOHEADER)::GlobalAlloc(GPTR, m_bitmapData.m_length);
|
||
memcpy(m_lpbiImage, // pColor is now pointing to the begining of the bitmap bits
|
||
pbitmapCreatePDU->nonStandardParameters->value.data.value,
|
||
m_bitmapData.m_length);
|
||
}
|
||
|
||
m_fMoreToFollow = pbitmapCreatePDU->moreToFollow;
|
||
|
||
|
||
// Create a memory DC compatible with the display
|
||
m_hMemDC = ::CreateCompatibleDC(NULL);
|
||
|
||
//
|
||
// If this is a remote pointer
|
||
//
|
||
if(m_ToolType == TOOLTYPE_REMOTEPOINTER)
|
||
{
|
||
CreateColoredIcon(0, m_lpbiImage, m_lpTransparencyMask);
|
||
CreateSaveBitmap();
|
||
}
|
||
|
||
|
||
}
|
||
|
||
void BitmapObj::Continue (BitmapCreateContinuePDU * pbitmapCreateContinuePDU)
|
||
{
|
||
//
|
||
// Get the continuation bitmap data
|
||
//
|
||
BYTE * pNewBitmapBuffer = NULL;
|
||
ULONG length = 0;
|
||
BYTE* pSentBuff;
|
||
|
||
//
|
||
// Allocate a buffer for the previous data and the one we just got, copy the old data in the new buffer
|
||
//
|
||
if(pbitmapCreateContinuePDU->bit_mask == BitmapCreateContinuePDU_nonStandardParameters_present)
|
||
{
|
||
length = pbitmapCreateContinuePDU->nonStandardParameters->value.data.length;
|
||
pSentBuff = pbitmapCreateContinuePDU->nonStandardParameters->value.data.value;
|
||
}
|
||
else
|
||
{
|
||
return;
|
||
}
|
||
|
||
//
|
||
// Copy the old data
|
||
//
|
||
pNewBitmapBuffer = (BYTE *)::GlobalAlloc(GPTR, m_bitmapData.m_length + length);
|
||
if(pNewBitmapBuffer == NULL)
|
||
{
|
||
TRACE_DEBUG(("Could not allocate memory size = %d)", m_bitmapData.m_length + length));
|
||
return;
|
||
}
|
||
|
||
memcpy(pNewBitmapBuffer, m_lpbiImage, m_bitmapData.m_length);
|
||
|
||
TRACE_DEBUG(("BitmapObj::Continue length = %d moreToFollow = %d)", length, pbitmapCreateContinuePDU->moreToFollow));
|
||
|
||
//
|
||
// Copy the new data
|
||
//
|
||
memcpy(pNewBitmapBuffer + m_bitmapData.m_length, pSentBuff, length);
|
||
|
||
//
|
||
// delete the old buffer
|
||
//
|
||
::GlobalFree((HGLOBAL)m_lpbiImage);
|
||
|
||
//
|
||
// Update bitmap data info
|
||
//
|
||
m_lpbiImage = (LPBITMAPINFOHEADER)pNewBitmapBuffer;
|
||
m_bitmapData.m_length += length;
|
||
m_lpbiImage->biSizeImage += length;
|
||
|
||
m_fMoreToFollow = pbitmapCreateContinuePDU->moreToFollow;
|
||
}
|
||
|
||
|
||
BitmapObj::BitmapObj (UINT toolType)
|
||
{
|
||
|
||
SetType(bitmapCreatePDU_chosen);
|
||
ResetAttrib();
|
||
SetOwnerID(g_MyMemberID);
|
||
SetMyWorkspace(NULL);
|
||
m_ToolType = toolType;
|
||
m_lpTransparencyMask = NULL;
|
||
m_lpbiImage = NULL;
|
||
m_lpBitMask = NULL;
|
||
m_hSaveBitmap = NULL;
|
||
m_hOldBitmap = NULL;
|
||
m_fMoreToFollow = FALSE;
|
||
|
||
//
|
||
// Created locally, not selected, not editing or deleting.
|
||
//
|
||
CreatedLocally();
|
||
ClearSelectionFlags();
|
||
ClearEditionFlags();
|
||
ClearDeletionFlags();
|
||
|
||
SetPenThickness(0);
|
||
|
||
//
|
||
// Set it to 0 so it boundsRect == rect
|
||
//
|
||
RECT rect;
|
||
::SetRectEmpty(&rect);
|
||
SetRect(&rect);
|
||
|
||
|
||
SetWorkspaceHandle(g_pCurrentWorkspace == NULL ? 0 : g_pCurrentWorkspace->GetWorkspaceHandle());
|
||
SetPlaneID(1);
|
||
|
||
SetViewState(unselected_chosen);
|
||
SetZOrder(front);
|
||
SetAnchorPoint(0,0);
|
||
|
||
if(m_ToolType == TOOLTYPE_REMOTEPOINTER)
|
||
{
|
||
// We haven't yet created our mem DC
|
||
m_hSaveBitmap = NULL;
|
||
m_hOldBitmap = NULL;
|
||
|
||
// Set the bounding rectangle of the object
|
||
rect.left = 0;
|
||
rect.top = 0;
|
||
rect.right = ::GetSystemMetrics(SM_CXICON);
|
||
rect.bottom = ::GetSystemMetrics(SM_CYICON);
|
||
SetRect(&rect);
|
||
}
|
||
|
||
// Show that we do not have an icon for drawing yet
|
||
m_hIcon = NULL;
|
||
|
||
// Create a memory DC compatible with the display
|
||
m_hMemDC = ::CreateCompatibleDC(NULL);
|
||
|
||
}
|
||
|
||
BitmapObj::~BitmapObj( void )
|
||
{
|
||
RemoveObjectFromResendList(this);
|
||
RemoveObjectFromRequestHandleList(this);
|
||
|
||
if(GetMyWorkspace() != NULL && WasDeletedLocally())
|
||
{
|
||
OnObjectDelete();
|
||
}
|
||
::GlobalFree((HGLOBAL)m_lpbiImage);
|
||
|
||
DeleteSavedBitmap();
|
||
|
||
if (m_hMemDC != NULL)
|
||
{
|
||
::DeleteDC(m_hMemDC);
|
||
m_hMemDC = NULL;
|
||
}
|
||
|
||
if(g_pMain && g_pMain->m_pLocalRemotePointer == this)
|
||
{
|
||
GetAnchorPoint(&g_pMain->m_localRemotePointerPosition);
|
||
g_pMain->m_pLocalRemotePointer = NULL;
|
||
g_pMain->m_TB.PopUp(IDM_REMOTE);
|
||
}
|
||
|
||
if(m_lpTransparencyMask)
|
||
{
|
||
delete m_lpTransparencyMask;
|
||
m_lpTransparencyMask = NULL;
|
||
}
|
||
|
||
if(m_hIcon)
|
||
{
|
||
::DestroyIcon(m_hIcon);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
void BitmapObj::BitmapEditObj (BitmapEditPDU * pbitmapEditPDU )
|
||
{
|
||
RECT rect;
|
||
POSITION pos;
|
||
POINT anchorPoint;
|
||
LONG deltaX = 0;
|
||
LONG deltaY = 0;
|
||
|
||
TRACE_MSG(("bitmapHandle = %d", pbitmapEditPDU->bitmapHandle ));
|
||
|
||
//
|
||
// Was edited remotely
|
||
//
|
||
ClearEditionFlags();
|
||
|
||
//
|
||
// Read attributes
|
||
//
|
||
if(pbitmapEditPDU->bit_mask & BitmapEditPDU_attributeEdits_present)
|
||
{
|
||
GetBitmapAttrib((PBitmapCreatePDU_attributes)pbitmapEditPDU->attributeEdits);
|
||
}
|
||
|
||
//
|
||
// Change the anchor point
|
||
//
|
||
GetAnchorPoint(&anchorPoint);
|
||
if(pbitmapEditPDU->bit_mask & BitmapEditPDU_anchorPointEdit_present)
|
||
{
|
||
|
||
TRACE_DEBUG(("Old anchor point (%d,%d)", anchorPoint.x, anchorPoint.y));
|
||
TRACE_DEBUG(("New anchor point (%d,%d)",
|
||
pbitmapEditPDU->anchorPointEdit.xCoordinate, pbitmapEditPDU->anchorPointEdit.yCoordinate));
|
||
//
|
||
// Get the delta from previous anchor point
|
||
//
|
||
deltaX = pbitmapEditPDU->anchorPointEdit.xCoordinate - anchorPoint.x;
|
||
deltaY = pbitmapEditPDU->anchorPointEdit.yCoordinate - anchorPoint.y;
|
||
TRACE_DEBUG(("Delta (%d,%d)", deltaX , deltaY));
|
||
|
||
//
|
||
// Was edited remotely
|
||
//
|
||
ClearEditionFlags();
|
||
|
||
//
|
||
// Set new anchor point
|
||
//
|
||
anchorPoint.x = pbitmapEditPDU->anchorPointEdit.xCoordinate;
|
||
anchorPoint.y = pbitmapEditPDU->anchorPointEdit.yCoordinate;
|
||
SetAnchorPoint(anchorPoint.x, anchorPoint.y);
|
||
|
||
GetRect(&rect);
|
||
::OffsetRect(&rect, deltaX, deltaY);
|
||
SetRect(&rect);
|
||
}
|
||
|
||
|
||
// if(pbitmapEditPDU->bit_mask & BitmapEditPDU_nonStandardParameters_present)
|
||
// {
|
||
// ; // Do the non Standard Edit PDU NYI
|
||
// }
|
||
|
||
if(HasAnchorPointChanged())
|
||
{
|
||
g_pDraw->EraseInitialDrawFinal(0 - deltaX,0 - deltaY, FALSE, (T126Obj*)this);
|
||
GetBoundsRect(&rect);
|
||
g_pDraw->InvalidateSurfaceRect(&rect,TRUE);
|
||
}
|
||
else if(HasZOrderChanged())
|
||
{
|
||
if(GetZOrder() == front)
|
||
{
|
||
g_pDraw->BringToTopSelection(FALSE, this);
|
||
}
|
||
else
|
||
{
|
||
g_pDraw->SendToBackSelection(FALSE, this);
|
||
}
|
||
|
||
}
|
||
//
|
||
// If it just select/unselected it
|
||
//
|
||
else if(HasViewStateChanged())
|
||
{
|
||
}
|
||
else
|
||
{
|
||
Draw();
|
||
}
|
||
|
||
//
|
||
// Reset all the attributes
|
||
//
|
||
ResetAttrib();
|
||
|
||
}
|
||
|
||
void BitmapObj::GetBitmapAttrib(PBitmapCreatePDU_attributes pAttribPDU)
|
||
{
|
||
|
||
PBitmapCreatePDU_attributes attributes;
|
||
attributes = (PBitmapCreatePDU_attributes)pAttribPDU;
|
||
while(attributes)
|
||
{
|
||
switch(attributes->value.choice)
|
||
{
|
||
|
||
case(BitmapAttribute_viewState_chosen):
|
||
{
|
||
|
||
if((attributes->value.u.viewState).choice != nonStandardViewState_chosen)
|
||
{
|
||
SetViewState(attributes->value.u.viewState.choice);
|
||
|
||
//
|
||
// If the other node is selecting the drawing or unselecting
|
||
//
|
||
if(attributes->value.u.viewState.choice == selected_chosen)
|
||
{
|
||
SelectedRemotely();
|
||
}
|
||
else if(attributes->value.u.viewState.choice == unselected_chosen)
|
||
{
|
||
ClearSelectionFlags();
|
||
}
|
||
|
||
TRACE_MSG(("Attribute viewState %d", attributes->value.u.viewState.choice));
|
||
}
|
||
else
|
||
{
|
||
// Do the non Standard view state
|
||
;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case(BitmapAttribute_zOrder_chosen):
|
||
{
|
||
SetZOrder(attributes->value.u.zOrder);
|
||
TRACE_MSG(("Attribute zOrder %d", attributes->value.u.zOrder));
|
||
break;
|
||
}
|
||
|
||
case(BitmapAttribute_transparencyMask_chosen):
|
||
{
|
||
TRACE_MSG(("Attribute transparencyMask"));
|
||
if(attributes->value.u.transparencyMask.bitMask.choice == uncompressed_chosen)
|
||
{
|
||
m_SizeOfTransparencyMask = attributes->value.u.transparencyMask.bitMask.u.uncompressed.length;
|
||
DBG_SAVE_FILE_LINE
|
||
m_lpTransparencyMask = new BYTE[m_SizeOfTransparencyMask];
|
||
|
||
memcpy(m_lpTransparencyMask, attributes->value.u.transparencyMask.bitMask.u.uncompressed.value, m_SizeOfTransparencyMask);
|
||
|
||
//
|
||
// Asn wants it top bottom left right
|
||
//
|
||
// BYTE swapByte;
|
||
// for (UINT i=0; i <m_SizeOfTransparencyMask ; i++)
|
||
// {
|
||
// swapByte = attributes->value.u.transparencyMask.bitMask.u.uncompressed.value[i];
|
||
// m_lpTransparencyMask [i] = ~(((swapByte >> 4) & 0x0f) | ((swapByte << 4)));
|
||
// }
|
||
}
|
||
break;
|
||
}
|
||
|
||
case(DrawingAttribute_nonStandardAttribute_chosen):
|
||
{
|
||
break; // NYI
|
||
}
|
||
|
||
default:
|
||
WARNING_OUT(("Invalid attributes choice"));
|
||
break;
|
||
}
|
||
|
||
attributes = attributes->next;
|
||
}
|
||
}
|
||
|
||
void BitmapObj::CreateNonStandard24BitBitmap(BitmapCreatePDU * pBitmapCreatePDU)
|
||
{
|
||
pBitmapCreatePDU->bit_mask |= BitmapCreatePDU_nonStandardParameters_present;
|
||
|
||
//
|
||
// Create the bitmpa header because it is not optional
|
||
//
|
||
pBitmapCreatePDU->bitmapFormatHeader.choice = bitmapHeaderNonStandard_chosen;
|
||
pBitmapCreatePDU->bitmapFormatHeader.u.bitmapHeaderNonStandard.nonStandardIdentifier.choice = bitmapHeaderNonStandard_chosen;
|
||
CreateNonStandardPDU(&pBitmapCreatePDU->bitmapFormatHeader.u.bitmapHeaderNonStandard, NonStandard24BitBitmapID);
|
||
pBitmapCreatePDU->bitmapFormatHeader.u.bitmapHeaderNonStandard.data.length = 0;
|
||
pBitmapCreatePDU->bitmapFormatHeader.u.bitmapHeaderNonStandard.data.value = NULL;
|
||
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pBitmapCreatePDU->nonStandardParameters = new BitmapCreatePDU_nonStandardParameters;
|
||
pBitmapCreatePDU->nonStandardParameters->next = NULL;
|
||
CreateNonStandardPDU(&pBitmapCreatePDU->nonStandardParameters->value, NonStandard24BitBitmapID);
|
||
|
||
}
|
||
|
||
|
||
void BitmapObj::CreateBitmapCreatePDU(CWBOBLIST * pCreatePDUList)
|
||
{
|
||
|
||
if(m_lpbiImage == NULL)
|
||
{
|
||
TRACE_MSG(("We dont have a bitmap structure to sent"));
|
||
return;
|
||
}
|
||
|
||
|
||
SIPDU *sipdu = NULL;
|
||
DBG_SAVE_FILE_LINE
|
||
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
||
if(!sipdu)
|
||
{
|
||
TRACE_MSG(("Failed to create sipdu"));
|
||
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
||
return;
|
||
}
|
||
|
||
//
|
||
// This is the first bitmap create pdu
|
||
//
|
||
sipdu->choice = bitmapCreatePDU_chosen;
|
||
BitmapCreatePDU *pCreatePDU = &sipdu->u.bitmapCreatePDU;
|
||
|
||
pCreatePDU->bit_mask = 0;
|
||
pCreatePDU->nonStandardParameters = NULL;
|
||
|
||
//
|
||
// Pass the bitmap Handle
|
||
//
|
||
pCreatePDU->bitmapHandle = GetThisObjectHandle();
|
||
|
||
//
|
||
// Pass the destination adress
|
||
//
|
||
if( m_ToolType == TOOLTYPE_REMOTEPOINTER)
|
||
{
|
||
pCreatePDU->destinationAddress.choice = softCopyPointerPlane_chosen;
|
||
pCreatePDU->destinationAddress.u.softCopyPointerPlane.workspaceHandle = GetMyWorkspace()->GetWorkspaceHandle();
|
||
}
|
||
else
|
||
{
|
||
pCreatePDU->destinationAddress.choice = BitmapDestinationAddress_softCopyImagePlane_chosen;
|
||
pCreatePDU->destinationAddress.u.softCopyImagePlane.workspaceHandle = GetMyWorkspace()->GetWorkspaceHandle();
|
||
pCreatePDU->destinationAddress.u.softCopyImagePlane.plane = (DataPlaneID)GetPlaneID();
|
||
}
|
||
|
||
//
|
||
// Pass the bitmap attributes
|
||
//
|
||
pCreatePDU->bit_mask |=BitmapCreatePDU_attributes_present;
|
||
SetBitmapAttrib(&pCreatePDU->attributes);
|
||
|
||
//
|
||
// Pass the anchor point
|
||
//
|
||
pCreatePDU->bit_mask |=BitmapCreatePDU_anchorPoint_present;
|
||
POINT point;
|
||
GetAnchorPoint(&point);
|
||
pCreatePDU->anchorPoint.xCoordinate = point.x;
|
||
pCreatePDU->anchorPoint.yCoordinate = point.y;
|
||
|
||
//
|
||
// Pass the bitmap size
|
||
//
|
||
pCreatePDU->bitmapSize.width = m_bitmapSize.x;
|
||
pCreatePDU->bitmapSize.height = m_bitmapSize.y;
|
||
|
||
//
|
||
// Pass bitmap region of interest
|
||
//
|
||
pCreatePDU->bit_mask |=bitmapRegionOfInterest_present;
|
||
BitmapRegion bitmapRegionOfInterest;
|
||
|
||
//
|
||
// Pass pixel aspect ratio
|
||
//
|
||
pCreatePDU->pixelAspectRatio.choice = PixelAspectRatio_square_chosen;
|
||
|
||
//
|
||
// Pass scaling factor
|
||
//
|
||
// pCreatePDU->bit_mask |=BitmapCreatePDU_scaling_present;
|
||
// pCreatePDU->scaling.xCoordinate = 0;
|
||
// pCreatePDU->scaling.yCoordinate = 0;
|
||
|
||
//
|
||
// Pass check points
|
||
//
|
||
// pCreatePDU->bit_mask |=checkpoints_present;
|
||
// pCreatePDU->checkpoints;
|
||
|
||
//
|
||
// JOSEF If we want > 8 have to recalculate to 24
|
||
//
|
||
|
||
LPSTR pDIB_bits;
|
||
LPBITMAPINFOHEADER lpbi8 = m_lpbiImage;
|
||
HDC hdc = NULL;
|
||
HBITMAP hbmp = NULL;
|
||
DWORD sizeOfBmpData = 0;
|
||
|
||
if(!g_pNMWBOBJ->CanDo24BitBitmaps())
|
||
{
|
||
|
||
hdc = GetDC(NULL);
|
||
|
||
BITMAPINFOHEADER lpbmih;
|
||
if(lpbi8->biBitCount > MAX_BITS_PERPIXEL)
|
||
{
|
||
|
||
lpbmih.biSize = sizeof(BITMAPINFOHEADER);
|
||
lpbmih.biWidth = lpbi8->biWidth;
|
||
lpbmih.biHeight = lpbi8->biHeight;
|
||
lpbmih.biPlanes = 1;
|
||
lpbmih.biBitCount = MAX_BITS_PERPIXEL;
|
||
lpbmih.biCompression = lpbi8->biCompression;
|
||
lpbmih.biSizeImage = lpbi8->biSizeImage;
|
||
lpbmih.biXPelsPerMeter = lpbi8->biXPelsPerMeter;
|
||
lpbmih.biYPelsPerMeter = lpbi8->biYPelsPerMeter;
|
||
lpbmih.biClrUsed = lpbi8->biClrUsed;
|
||
lpbmih.biClrImportant = lpbi8->biClrImportant;
|
||
|
||
hbmp = CreateDIBitmap(hdc, &lpbmih, CBM_INIT, DIB_Bits(lpbi8),(LPBITMAPINFO)lpbi8, DIB_RGB_COLORS);
|
||
lpbi8 = DIB_FromBitmap(hbmp, NULL, FALSE, FALSE);
|
||
}
|
||
}
|
||
|
||
pDIB_bits = (LPSTR)lpbi8;
|
||
sizeOfBmpData = DIB_TotalLength(lpbi8);
|
||
|
||
|
||
|
||
//
|
||
// Sending data
|
||
//
|
||
BOOL bMoreToFollow = FALSE;
|
||
DWORD length = sizeOfBmpData;
|
||
|
||
pCreatePDU->bitmapData.bit_mask = 0;
|
||
|
||
if(sizeOfBmpData > MAX_BITMAP_DATA)
|
||
{
|
||
length = MAX_BITMAP_DATA;
|
||
bMoreToFollow = TRUE;
|
||
}
|
||
|
||
pCreatePDU->moreToFollow = (ASN1bool_t)bMoreToFollow;
|
||
//
|
||
// Pass the bitmap info
|
||
//
|
||
pCreatePDU->bit_mask |= BitmapCreatePDU_nonStandardParameters_present;
|
||
CreateNonStandard24BitBitmap(&sipdu->u.bitmapCreatePDU);
|
||
pCreatePDU->nonStandardParameters->value.data.length = length;
|
||
pCreatePDU->nonStandardParameters->value.data.value = (ASN1octet_t *)pDIB_bits;
|
||
|
||
//
|
||
// We are not passing it into the data field
|
||
//
|
||
pCreatePDU->bitmapData.bit_mask = 0;
|
||
pCreatePDU->bitmapData.data.length = 1;
|
||
|
||
pCreatePDUList->AddTail(sipdu);
|
||
|
||
BitmapCreateContinuePDU * pCreateContinuePDU;
|
||
while(bMoreToFollow)
|
||
{
|
||
//
|
||
// Advance the pointer
|
||
//
|
||
pDIB_bits += MAX_BITMAP_DATA;
|
||
sizeOfBmpData-= MAX_BITMAP_DATA;
|
||
|
||
if(sizeOfBmpData > MAX_BITMAP_DATA)
|
||
{
|
||
length = MAX_BITMAP_DATA;
|
||
}
|
||
else
|
||
{
|
||
length = sizeOfBmpData;
|
||
bMoreToFollow = FALSE;
|
||
}
|
||
|
||
//
|
||
// Create a new BitmapCreateContinuePDU
|
||
//
|
||
sipdu = NULL;
|
||
DBG_SAVE_FILE_LINE
|
||
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
||
if(!sipdu)
|
||
{
|
||
TRACE_MSG(("Failed to create sipdu"));
|
||
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
||
return;
|
||
}
|
||
|
||
sipdu->choice = bitmapCreateContinuePDU_chosen;
|
||
pCreateContinuePDU = &sipdu->u.bitmapCreateContinuePDU;
|
||
|
||
pCreateContinuePDU->bit_mask = 0;
|
||
pCreateContinuePDU->nonStandardParameters = NULL;
|
||
|
||
|
||
//
|
||
// Pass the bitmap Handle
|
||
//
|
||
pCreateContinuePDU->bitmapHandle = GetThisObjectHandle();
|
||
|
||
//
|
||
// Pass the data
|
||
//
|
||
pCreateContinuePDU->bit_mask |= BitmapCreateContinuePDU_nonStandardParameters_present;
|
||
|
||
//
|
||
// Pass the bitmap info
|
||
//
|
||
DBG_SAVE_FILE_LINE
|
||
pCreateContinuePDU->nonStandardParameters = new BitmapCreateContinuePDU_nonStandardParameters;
|
||
pCreateContinuePDU->nonStandardParameters->next = NULL;
|
||
|
||
CreateNonStandardPDU(&pCreateContinuePDU->nonStandardParameters->value, NonStandard24BitBitmapID);
|
||
pCreateContinuePDU->nonStandardParameters->value.data.length = length;
|
||
pCreateContinuePDU->nonStandardParameters->value.data.value = (ASN1octet_t *)pDIB_bits;
|
||
|
||
//
|
||
// We are not passing it into the data field
|
||
//
|
||
pCreateContinuePDU->bitmapData.bit_mask = 0;
|
||
pCreateContinuePDU->bitmapData.data.length = 1;
|
||
|
||
pCreateContinuePDU->moreToFollow = (ASN1bool_t) bMoreToFollow;
|
||
pCreatePDUList->AddTail(sipdu);
|
||
|
||
}
|
||
|
||
if(hbmp)
|
||
{
|
||
DeleteObject(hbmp);
|
||
}
|
||
|
||
if(hdc)
|
||
{
|
||
ReleaseDC(NULL, hdc);
|
||
}
|
||
}
|
||
|
||
void BitmapObj::CreateBitmapEditPDU(BitmapEditPDU *pEditPDU)
|
||
{
|
||
pEditPDU->bit_mask = (ASN1uint16_t) GetPresentAttribs();
|
||
|
||
//
|
||
// Pass the anchor point
|
||
//
|
||
if(HasAnchorPointChanged())
|
||
{
|
||
POINT point;
|
||
GetAnchorPoint(&point);
|
||
pEditPDU->anchorPointEdit.xCoordinate = point.x;
|
||
pEditPDU->anchorPointEdit.yCoordinate = point.y;
|
||
}
|
||
|
||
//
|
||
// JOSEF Pass Region of interest (FEATURE)
|
||
//
|
||
|
||
//
|
||
// JOSEF Pass scaling (FEATURE)
|
||
//
|
||
|
||
//
|
||
// Pass all the changed attributes, if any.
|
||
//
|
||
pEditPDU->attributeEdits = NULL;
|
||
if(pEditPDU->bit_mask & BitmapEditPDU_attributeEdits_present)
|
||
{
|
||
SetBitmapAttrib((PBitmapCreatePDU_attributes *)&pEditPDU->attributeEdits);
|
||
}
|
||
|
||
pEditPDU->bitmapHandle = GetThisObjectHandle();
|
||
|
||
}
|
||
|
||
void BitmapObj::CreateBitmapDeletePDU(BitmapDeletePDU *pDeletePDU)
|
||
{
|
||
pDeletePDU->bit_mask = 0;
|
||
pDeletePDU->bitmapHandle = GetThisObjectHandle();
|
||
}
|
||
|
||
|
||
void BitmapObj::AllocateAttrib(PBitmapCreatePDU_attributes *pAttributes)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
PBitmapCreatePDU_attributes pAttrib = (PBitmapCreatePDU_attributes)new BYTE[sizeof(BitmapCreatePDU_attributes)];
|
||
if(*pAttributes == NULL)
|
||
{
|
||
*pAttributes = pAttrib;
|
||
pAttrib->next = NULL;
|
||
}
|
||
else
|
||
{
|
||
((PBitmapCreatePDU_attributes)pAttrib)->next = *pAttributes;
|
||
*pAttributes = pAttrib;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
void BitmapObj::SetBitmapAttrib(PBitmapCreatePDU_attributes *pattributes)
|
||
{
|
||
PBitmapCreatePDU_attributes attributes = NULL;
|
||
|
||
//
|
||
// Do the viewState
|
||
//
|
||
if(HasViewStateChanged())
|
||
{
|
||
AllocateAttrib(&attributes);
|
||
attributes->value.choice = BitmapAttribute_viewState_chosen;
|
||
attributes->value.u.viewState.choice = (ASN1choice_t)GetViewState();
|
||
}
|
||
|
||
//
|
||
// Do the zOrder
|
||
//
|
||
if(HasZOrderChanged())
|
||
{
|
||
AllocateAttrib(&attributes);
|
||
attributes->value.choice = BitmapAttribute_zOrder_chosen;
|
||
attributes->value.u.zOrder = GetZOrder();
|
||
}
|
||
|
||
|
||
//
|
||
// Do the Transparency
|
||
//
|
||
if(HasTransparencyMaskChanged())
|
||
{
|
||
AllocateAttrib(&attributes);
|
||
attributes->value.choice = BitmapAttribute_transparencyMask_chosen;
|
||
attributes->value.u.transparencyMask.bit_mask = 0;
|
||
attributes->value.u.transparencyMask.bitMask.choice = uncompressed_chosen;
|
||
attributes->value.u.transparencyMask.bitMask.u.uncompressed.length = m_SizeOfTransparencyMask;
|
||
attributes->value.u.transparencyMask.bitMask.u.uncompressed.value = m_lpTransparencyMask;
|
||
}
|
||
|
||
//
|
||
// End of attributes
|
||
//
|
||
*pattributes = attributes;
|
||
|
||
}
|
||
|
||
|
||
void BitmapObj::Draw(HDC hDC, BOOL bForcedDraw, BOOL bPrinting)
|
||
{
|
||
|
||
if(!bPrinting)
|
||
{
|
||
//
|
||
// Don't draw anything if we don't belong in this workspace
|
||
//
|
||
if(GetWorkspaceHandle() != g_pCurrentWorkspace->GetThisObjectHandle())
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
RECT clipBox;
|
||
RECT rect;
|
||
GetRect(&rect);
|
||
|
||
if(hDC == NULL)
|
||
{
|
||
hDC = g_pDraw->m_hDCCached;
|
||
}
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "BitmapObj::Draw");
|
||
|
||
// Only draw anything if the bounding rectangle intersects
|
||
// the current clip box.
|
||
if (::GetClipBox(hDC, &clipBox) == ERROR)
|
||
{
|
||
WARNING_OUT(("Failed to get clip box"));
|
||
}
|
||
else if (!::IntersectRect(&clipBox, &clipBox, &rect))
|
||
{
|
||
TRACE_MSG(("No clip/bounds intersection"));
|
||
return;
|
||
}
|
||
|
||
if(m_ToolType == TOOLTYPE_FILLEDBOX)
|
||
{
|
||
if(m_fMoreToFollow)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// Set the stretch mode to be used so that scan lines are deleted
|
||
// rather than combined. This will tend to preserve color better.
|
||
int iOldStretchMode = ::SetStretchBltMode(hDC, STRETCH_DELETESCANS);
|
||
|
||
// Draw the bitmap
|
||
::StretchDIBits(hDC,
|
||
rect.left,
|
||
rect.top,
|
||
rect.right - rect.left,
|
||
rect.bottom - rect.top,
|
||
0,
|
||
0,
|
||
(UINT) m_lpbiImage->biWidth,
|
||
(UINT) m_lpbiImage->biHeight,
|
||
(VOID FAR *) DIB_Bits(m_lpbiImage),
|
||
(LPBITMAPINFO)m_lpbiImage,
|
||
DIB_RGB_COLORS,
|
||
SRCCOPY);
|
||
|
||
// Restore the stretch mode
|
||
::SetStretchBltMode(hDC, iOldStretchMode);
|
||
}
|
||
else
|
||
{
|
||
// Create the save bitmap if necessary
|
||
CreateSaveBitmap();
|
||
|
||
// Draw the icon
|
||
::DrawIcon(hDC, rect.left, rect.top, m_hIcon);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: BitmapObj::::FromScreenArea
|
||
//
|
||
// Purpose: Set the content of the object from an area of the screen
|
||
//
|
||
//
|
||
void BitmapObj::FromScreenArea(LPCRECT lprcScreen)
|
||
{
|
||
m_lpbiImage = DIB_FromScreenArea(lprcScreen);
|
||
if (m_lpbiImage == NULL)
|
||
{
|
||
::Message(NULL, (UINT)IDS_MSG_CAPTION, (UINT)IDS_CANTGETBMP, (UINT)MB_OK );
|
||
}
|
||
else
|
||
{
|
||
|
||
m_bitmapSize.x = m_lpbiImage->biWidth;
|
||
m_bitmapSize.y = m_lpbiImage->biHeight;
|
||
|
||
RECT rect;
|
||
GetBoundsRect(&rect);
|
||
// Calculate the bounding rectangle from the size of the bitmap
|
||
rect.right = rect.left + m_lpbiImage->biWidth;
|
||
rect.bottom = rect.top + m_lpbiImage->biHeight;
|
||
SetRect(&rect);
|
||
}
|
||
}
|
||
|
||
|
||
UINT GetBitmapDestinationAddress(BitmapDestinationAddress *destinationAddress, PUINT workspaceHandle, PUINT planeID)
|
||
{
|
||
UINT toolType = TOOLTYPE_FILLEDBOX;
|
||
|
||
//
|
||
// Get the destination address
|
||
//
|
||
switch(destinationAddress->choice)
|
||
{
|
||
|
||
case(BitmapDestinationAddress_softCopyImagePlane_chosen):
|
||
{
|
||
*workspaceHandle = (destinationAddress->u.softCopyImagePlane.workspaceHandle);
|
||
*planeID = (destinationAddress->u.softCopyImagePlane.plane);
|
||
break;
|
||
}
|
||
case(BitmapDestinationAddress_softCopyAnnotationPlane_chosen):
|
||
{
|
||
*workspaceHandle = (destinationAddress->u.softCopyAnnotationPlane.workspaceHandle);
|
||
*planeID = (destinationAddress->u.softCopyAnnotationPlane.plane);
|
||
break;
|
||
}
|
||
case(softCopyPointerPlane_chosen):
|
||
{
|
||
*workspaceHandle = (destinationAddress->u.softCopyPointerPlane.workspaceHandle);
|
||
*planeID = (0);
|
||
toolType = TOOLTYPE_REMOTEPOINTER;
|
||
break;
|
||
}
|
||
|
||
// case(BitmapDestinationAddress_nonStandardDestination_chosen):
|
||
// {
|
||
// break;
|
||
// }
|
||
|
||
default:
|
||
ERROR_OUT(("Invalid destinationAddress"));
|
||
break;
|
||
}
|
||
return toolType;
|
||
}
|
||
|
||
|
||
//
|
||
// UI Edited the Bitmap Object
|
||
//
|
||
void BitmapObj::OnObjectEdit(void)
|
||
{
|
||
g_bContentsChanged = TRUE;
|
||
|
||
SIPDU *sipdu = NULL;
|
||
DBG_SAVE_FILE_LINE
|
||
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
||
if(sipdu)
|
||
{
|
||
sipdu->choice = bitmapEditPDU_chosen;
|
||
CreateBitmapEditPDU(&sipdu->u.bitmapEditPDU);
|
||
T120Error rc = SendT126PDU(sipdu);
|
||
if(rc == T120_NO_ERROR)
|
||
{
|
||
SIPDUCleanUp(sipdu);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TRACE_MSG(("Failed to create sipdu"));
|
||
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
// UI Deleted the Bitmap Object
|
||
//
|
||
void BitmapObj::OnObjectDelete(void)
|
||
{
|
||
SIPDU *sipdu = NULL;
|
||
DBG_SAVE_FILE_LINE
|
||
sipdu = (SIPDU *) new BYTE[sizeof(SIPDU)];
|
||
if(sipdu)
|
||
{
|
||
sipdu->choice = bitmapDeletePDU_chosen;
|
||
CreateBitmapDeletePDU(&sipdu->u.bitmapDeletePDU);
|
||
T120Error rc = SendT126PDU(sipdu);
|
||
if(rc == T120_NO_ERROR)
|
||
{
|
||
SIPDUCleanUp(sipdu);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TRACE_MSG(("Failed to create sipdu"));
|
||
::PostMessage(g_pMain->m_hwnd, WM_USER_DISPLAY_ERROR, WBFE_RC_WINDOWS, 0);
|
||
}
|
||
|
||
}
|
||
|
||
void BitmapObj::GetEncodedCreatePDU(ASN1_BUF *pBuf)
|
||
{
|
||
pBuf->length = DIB_TotalLength(m_lpbiImage);
|
||
pBuf->value = (PBYTE)m_lpbiImage;
|
||
}
|
||
|
||
|
||
|
||
//
|
||
// UI Created a new Bitmap Object
|
||
//
|
||
void BitmapObj::SendNewObjectToT126Apps(void)
|
||
{
|
||
SIPDU *sipdu = NULL;
|
||
CWBOBLIST BitmapContinueCreatePDUList;
|
||
BitmapContinueCreatePDUList.EmptyList();
|
||
CreateBitmapCreatePDU(&BitmapContinueCreatePDUList);
|
||
T120Error rc = T120_NO_ERROR;
|
||
|
||
WBPOSITION pos = BitmapContinueCreatePDUList.GetHeadPosition();
|
||
while (pos != NULL)
|
||
{
|
||
sipdu = (SIPDU *) BitmapContinueCreatePDUList.GetNext(pos);
|
||
TRACE_DEBUG(("Sending Bitmap >> Bitmap handle = %d", sipdu->u.bitmapCreatePDU.bitmapHandle ));
|
||
if(g_bSavingFile && GraphicTool() == TOOLTYPE_REMOTEPOINTER)
|
||
{
|
||
; // Don't send Remote pointers to disk
|
||
}
|
||
else
|
||
{
|
||
if(!m_fMoreToFollow)
|
||
{
|
||
rc = SendT126PDU(sipdu);
|
||
}
|
||
}
|
||
|
||
if(rc == T120_NO_ERROR)
|
||
{
|
||
SIPDUCleanUp(sipdu);
|
||
}
|
||
|
||
}
|
||
BitmapContinueCreatePDUList.EmptyList();
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
//
|
||
//
|
||
// Function: CreateColoredIcon
|
||
//
|
||
// Purpose: Create an icon of the correct color for this pointer.
|
||
//
|
||
//
|
||
HICON BitmapObj::CreateColoredIcon(COLORREF color, LPBITMAPINFOHEADER lpbInfo, LPBYTE pMaskBits)
|
||
{
|
||
HICON hColoredIcon = NULL;
|
||
HBRUSH hBrush = NULL;
|
||
HBRUSH hOldBrush;
|
||
HBITMAP hImage = NULL;
|
||
HBITMAP hOldBitmap;
|
||
HBITMAP hMask = NULL;
|
||
COLOREDICON *pColoredIcon;
|
||
ICONINFO ii;
|
||
UINT i;
|
||
LPSTR pBits;
|
||
LPBITMAPINFOHEADER lpbi;
|
||
BYTE swapByte;
|
||
|
||
color = SET_PALETTERGB(color);
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "RemotePointerObject::CreateColoredIcon");
|
||
|
||
//
|
||
// Create the mask for the icon with the data sent through T126
|
||
//
|
||
if(pMaskBits && lpbInfo)
|
||
{
|
||
hMask = CreateBitmap(lpbInfo->biWidth, lpbInfo->biHeight, 1, 1, m_lpTransparencyMask);
|
||
}
|
||
//
|
||
// Create the local mask
|
||
//
|
||
else
|
||
{
|
||
// Load the mask bitmap
|
||
hMask = ::LoadBitmap(g_hInstance, MAKEINTRESOURCE(REMOTEPOINTERANDMASK));
|
||
if (!hMask)
|
||
{
|
||
TRACE_MSG(("Could not load mask bitmap"));
|
||
goto CreateIconCleanup;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Create a bitmap with the data that sent through T126
|
||
//
|
||
if(lpbInfo)
|
||
{
|
||
VOID *ppvBits;
|
||
hImage = CreateDIBSection(m_hMemDC, (LPBITMAPINFO)lpbInfo, DIB_RGB_COLORS, &ppvBits, NULL, 0);
|
||
|
||
if(!ppvBits)
|
||
{
|
||
TRACE_MSG(("CreateColoredIcon failed calling CreateDIBSection error = %d", GetLastError()));
|
||
goto CreateIconCleanup;
|
||
}
|
||
|
||
|
||
pBits = DIB_Bits(lpbInfo);
|
||
|
||
::GetDIBits(m_hMemDC, hImage, 0, (WORD) lpbInfo->biHeight, NULL,(LPBITMAPINFO)lpbInfo, DIB_RGB_COLORS);
|
||
memcpy(ppvBits, pBits, lpbInfo->biSizeImage);
|
||
if(!hMask)
|
||
{
|
||
hMask = CreateBitmap(lpbInfo->biWidth, lpbInfo->biHeight, 1, 1, NULL);
|
||
}
|
||
}
|
||
//
|
||
// Create a local bitmap
|
||
//
|
||
else
|
||
{
|
||
// Load the image bitmap
|
||
hImage = ::LoadBitmap(g_hInstance, MAKEINTRESOURCE(REMOTEPOINTERXORDATA));
|
||
if (!hImage)
|
||
{
|
||
TRACE_MSG(("Could not load pointer bitmap"));
|
||
goto CreateIconCleanup;
|
||
}
|
||
|
||
hBrush = ::CreateSolidBrush(color);
|
||
if (!hBrush)
|
||
{
|
||
TRACE_MSG(("Couldn't create color brush"));
|
||
goto CreateIconCleanup;
|
||
}
|
||
|
||
// Select in the icon color
|
||
hOldBrush = SelectBrush(m_hMemDC, hBrush);
|
||
|
||
// Select the image bitmap into the memory DC
|
||
hOldBitmap = SelectBitmap(m_hMemDC, hImage);
|
||
|
||
if(!hOldBitmap)
|
||
{
|
||
ERROR_OUT(("DeleteSavedBitmap - Could not select old bitmap"));
|
||
}
|
||
|
||
// Fill the image bitmap with color
|
||
::FloodFill(m_hMemDC, ::GetSystemMetrics(SM_CXICON) / 2, ::GetSystemMetrics(SM_CYICON) / 2, RGB(0, 0, 0));
|
||
|
||
SelectBitmap(m_hMemDC, hOldBitmap);
|
||
|
||
SelectBrush(m_hMemDC, hOldBrush);
|
||
}
|
||
|
||
//
|
||
// Now use the image and mask bitmaps to create an icon
|
||
//
|
||
ii.fIcon = TRUE;
|
||
ii.xHotspot = 0;
|
||
ii.yHotspot = 0;
|
||
ii.hbmMask = hMask;
|
||
ii.hbmColor = hImage;
|
||
|
||
// Create a new icon from the data and mask
|
||
hColoredIcon = ::CreateIconIndirect(&ii);
|
||
|
||
//
|
||
// Create the internal format if we were created locally
|
||
//
|
||
if(m_lpbiImage == NULL)
|
||
{
|
||
m_lpbiImage = DIB_FromBitmap(hImage, NULL, FALSE, FALSE, TRUE);
|
||
}
|
||
|
||
if(m_lpTransparencyMask == NULL)
|
||
{
|
||
ChangedTransparencyMask();
|
||
|
||
lpbi = DIB_FromBitmap(hMask,NULL,FALSE, TRUE);
|
||
pBits = DIB_Bits(lpbi);
|
||
m_SizeOfTransparencyMask = lpbi->biSizeImage;
|
||
DBG_SAVE_FILE_LINE
|
||
m_lpTransparencyMask = new BYTE[m_SizeOfTransparencyMask];
|
||
memcpy(m_lpTransparencyMask, pBits, m_SizeOfTransparencyMask );
|
||
::GlobalFree(lpbi);
|
||
}
|
||
|
||
if (m_lpbiImage == NULL)
|
||
{
|
||
::Message(NULL, (UINT)IDS_MSG_CAPTION, (UINT)IDS_CANTGETBMP, (UINT)MB_OK );
|
||
}
|
||
else
|
||
{
|
||
|
||
m_bitmapSize.x = m_lpbiImage->biWidth;
|
||
m_bitmapSize.y = m_lpbiImage->biHeight;
|
||
|
||
RECT rect;
|
||
GetBoundsRect(&rect);
|
||
// Calculate the bounding rectangle from the size of the bitmap
|
||
rect.right = rect.left + m_lpbiImage->biWidth;
|
||
rect.bottom = rect.top + m_lpbiImage->biHeight;
|
||
SetRect(&rect);
|
||
SetAnchorPoint(rect.left, rect.top);
|
||
|
||
}
|
||
|
||
CreateIconCleanup:
|
||
|
||
// Free the image bitmap
|
||
if (hImage != NULL)
|
||
{
|
||
::DeleteBitmap(hImage);
|
||
}
|
||
|
||
// Free the mask bitmap
|
||
if (hMask != NULL)
|
||
{
|
||
::DeleteBitmap(hMask);
|
||
}
|
||
|
||
if (hBrush != NULL)
|
||
{
|
||
::DeleteBrush(hBrush);
|
||
}
|
||
|
||
m_hIcon = hColoredIcon;
|
||
|
||
return(hColoredIcon);
|
||
}
|
||
|
||
|
||
//
|
||
//
|
||
// Function: BitmapObj::CreateSaveBitmap()
|
||
//
|
||
// Purpose: Create a bitmap for saving the bits under the pointer.
|
||
//
|
||
//
|
||
void BitmapObj::CreateSaveBitmap()
|
||
{
|
||
MLZ_EntryOut(ZONE_FUNCTION, "BitmapObj::CreateSaveBitmap");
|
||
|
||
// If we already have a save bitmap, exit immediately
|
||
if (m_hSaveBitmap != NULL)
|
||
{
|
||
TRACE_MSG(("Already have save bitmap"));
|
||
return;
|
||
}
|
||
|
||
// Create a bitmap to save the bits under the icon. This bitmap is
|
||
// created with space for building the new screen image before
|
||
// blitting it to the screen.
|
||
RECT rect;
|
||
RECT rcVis;
|
||
|
||
POINT point;
|
||
POINT delta;
|
||
HDC hDC = NULL;
|
||
g_pDraw->GetVisibleRect(&rcVis);
|
||
GetRect(&rect);
|
||
|
||
delta.x = rect.right - rect.left;
|
||
delta.y = rect.bottom - rect.top;
|
||
|
||
point.x = rect.left - rcVis.left;
|
||
point.y = rect.top - rcVis.top;
|
||
|
||
ClientToScreen (g_pDraw->m_hwnd, &point);
|
||
|
||
rect.left = point.x;
|
||
rect.top = point.y;
|
||
rect.right = rect.left + delta.x;
|
||
rect.bottom = rect.top + delta.y;
|
||
|
||
//
|
||
// Create the bitmap
|
||
//
|
||
m_hSaveBitmap = FromScreenAreaBmp(&rect);
|
||
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: BitmapObj::Undraw()
|
||
//
|
||
// Purpose: Draw the marker object
|
||
//
|
||
//
|
||
void BitmapObj::UnDraw(void)
|
||
{
|
||
if(GraphicTool() == TOOLTYPE_REMOTEPOINTER)
|
||
{
|
||
|
||
// Create the save bitmap if necessary
|
||
CreateSaveBitmap();
|
||
|
||
//
|
||
// Select the saved area
|
||
//
|
||
if(m_hSaveBitmap)
|
||
{
|
||
m_hOldBitmap = SelectBitmap(m_hMemDC, m_hSaveBitmap);
|
||
if(!m_hOldBitmap)
|
||
{
|
||
ERROR_OUT(("DeleteSavedBitmap - Could not select old bitmap"));
|
||
}
|
||
}
|
||
|
||
// Copy the saved bits onto the screen
|
||
UndrawScreen();
|
||
}
|
||
else
|
||
{
|
||
RECT rect;
|
||
GetBoundsRect(&rect);
|
||
g_pDraw->InvalidateSurfaceRect(&rect,TRUE);
|
||
}
|
||
|
||
}
|
||
|
||
//
|
||
//
|
||
// Function: BitmapObj::UndrawScreen()
|
||
//
|
||
// Purpose: Copy the saved bits under the pointer to the screen.
|
||
//
|
||
//
|
||
BOOL BitmapObj::UndrawScreen()
|
||
{
|
||
BOOL bResult = FALSE;
|
||
RECT rcUpdate;
|
||
|
||
MLZ_EntryOut(ZONE_FUNCTION, "DCWbGraphicPointer::UndrawScreen");
|
||
|
||
GetRect(&rcUpdate);
|
||
|
||
|
||
// We are undrawing - copy the saved bits to the DC passed
|
||
bResult = ::BitBlt(g_pDraw->m_hDCCached, rcUpdate.left, rcUpdate.top,
|
||
rcUpdate.right - rcUpdate.left, rcUpdate.bottom - rcUpdate.top,
|
||
m_hMemDC, 0, 0, SRCCOPY);
|
||
|
||
if (!bResult)
|
||
{
|
||
WARNING_OUT(("UndrawScreen - Could not copy from bitmap"));
|
||
}
|
||
else
|
||
{
|
||
DeleteSavedBitmap();
|
||
}
|
||
|
||
|
||
return(bResult);
|
||
}
|
||
|
||
void BitmapObj::DeleteSavedBitmap(void)
|
||
{
|
||
|
||
// Restore the original bitmap to the memory DC
|
||
if (m_hOldBitmap != NULL)
|
||
{
|
||
if(!SelectBitmap(m_hMemDC, m_hOldBitmap))
|
||
{
|
||
ERROR_OUT(("DeleteSavedBitmap - Could not select old bitmap"));
|
||
}
|
||
|
||
// if(!DeleteBitmap(m_hOldBitmap))
|
||
// {
|
||
// ERROR_OUT(("DeleteSavedBitmap - Could not delete old bitmap"));
|
||
// }
|
||
m_hOldBitmap = NULL;
|
||
}
|
||
|
||
if (m_hSaveBitmap != NULL)
|
||
{
|
||
if(!DeleteBitmap(m_hSaveBitmap))
|
||
{
|
||
ERROR_OUT(("DeleteSavedBitmap - Could not delete bitmap"));
|
||
}
|
||
m_hSaveBitmap = NULL;
|
||
}
|
||
}
|
||
|