//************************************************************************
BOOL CDib::LoadFromResource(HINSTANCE hInstance, LPCSTR szResource, BOOL fDecodeRLE)
//************************************************************************
{
HRSRC hDibRes;
HGLOBAL hDib;
LPTR lpDib;
LPBITMAPINFO lpbmInfo;
DWORD dwBits;
if ( !(hDibRes = FindResource(hInstance, szResource, RT_BITMAP)) )
return(FALSE);
if (! (hDib = LoadResource(hInstance, hDibRes)) )
return(FALSE);
lpDib = (LPTR)LockResource(hDib);
if (!lpDib)
return(FALSE);
lpbmInfo = (LPBITMAPINFO)lpDib;
m_bmiHeader = lpbmInfo->bmiHeader;
FixHeader();
hmemcpy(m_rgbQuad, lpbmInfo->bmiColors, GetNumColors() * sizeof(RGBQUAD));
lpDib += m_bmiHeader.biSize + (GetNumColors() * sizeof(RGBQUAD));
// Can we get enough memory to hold the DIB bits
if ( (m_lp = AllocX( dwBits = GetSizeImage(), GMEM_ZEROINIT )) != NULL )
hmemcpy(m_lp, lpDib, dwBits);
UnlockResource(hDib);
FreeResource(hDib);
return(CheckDecodeRLE(fDecodeRLE));
}
//************************************************************************
CDib::CDib(PDIB pdib, LPTR lp, BOOL fCopyBits)
//************************************************************************
{
m_bmiHeader = *pdib->GetInfoHeader();
hmemcpy( m_rgbQuad, pdib->GetColors(), sizeof(m_rgbQuad));
m_lp = lp;
if (fCopyBits)
hmemcpy(m_lp, pdib->GetPtr(), pdib->GetSizeImage());
m_iRefCount = 0;
AddRef();
}
//************************************************************************
void CDib::SwapLines( int y1, int y2, int iCount )
//************************************************************************
{
HPTR lpLineB, lpSwap1, lpSwap2;
int iHeight = abs( GetHeight() );
int iWidth = GetWidthBytes();
if ( m_bmiHeader.biCompression != BI_RGB )
return;
if ( !(lpSwap1 = GetXY( 0, y1 )) )
return;
if ( !(lpSwap2 = GetXY( 0, y2 )) )
return;
if ( !(lpLineB = Alloc( iWidth )) )
return;
if ( y1 < 0 )
y1 = -y1;
if ( y1 >= iHeight )
y1 = iHeight-1;
if ( y2 < 0 )
y2 = -y2;
if ( y2 >= iHeight )
y2 = iHeight-1;
if ( iCount < 0 )
iCount = -iCount;
if ( y1 + iCount > iHeight )
iCount = iHeight - y1;
if ( y2 + iCount > iHeight )
iCount = iHeight - y2;
int iDelta = ( GetHeight() < 0 ? iWidth : -iWidth ); // if its an upside down DIB...
while ( --iCount >= 0 )
{
hmemcpy( lpLineB, lpSwap2, iWidth );
hmemcpy( lpSwap2, lpSwap1, iWidth );
hmemcpy( lpSwap1, lpLineB, iWidth );
lpSwap1 += iDelta;
lpSwap2 += iDelta;
}
FreeUp( lpLineB );
}
//************************************************************************
void CDib::CopyColorTable( PDIB pdibSrc )
//************************************************************************
{
m_bmiHeader.biClrUsed = pdibSrc->m_bmiHeader.biClrUsed;
m_bmiHeader.biClrImportant = pdibSrc->m_bmiHeader.biClrImportant;
hmemcpy( m_rgbQuad, pdibSrc->GetColors(), sizeof(m_rgbQuad));
}
long UPSF::xxxx_To_UFon(
HGLOBAL& hUniv,
long& univSize,
long natv,
void* natvPtr,
long natvLen)
{
univSize = natvLen;
if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))
return AUPSF_MEMORYERROR;
long* univPtr = (long*)GlobalLock(hUniv);
if(!univPtr)
return AUPSF_MEMORYERROR;
long retValue = AUPSF_NOERROR;
if(natv==AUPSF_NATV_FONT)
{
// just store the font name--each platform will convert on import
// the attributes will be stored separately
hmemcpy(univPtr, natvPtr, natvLen);
}
else
retValue = AUPSF_CANTCONVERT;
GlobalUnlock(hUniv);
return retValue;
}
///////////////////////////////////////////////
// Copy your memory to another memory location
///////////////////////////////////////////////
VOIDPTR HFMemCopy(VOIDPTR pDest, VOIDPTR pSrc, DWORD dwNBytes)
{
//// A Windows 3.1 specific call... ////
hmemcpy(pDest, pSrc, (LONG) dwNBytes);
/////////////////////////////////////////////////
// Here's how one might code the above function:
/////////////////////////////////////////////////
/*
DWORD dwBytesLeft;
BYTEPTR pTempSrc = (BYTEPTR) pSrc;
BYTEPTR pTempDest = (BYTEPTR) pDest;
if (dwNBytes != 0)
{
//// Decrement for zero-based indexing ////
dwNBytes--;
while (dwNBytes > 0)
{
pTempDest[dwNBytes] = pTempSrc[dwNBytes];
dwNBytes--;
}
//// Pick up the last byte ////
pTempDest[0] = pTempSrc[0];
}
*/
return ((VOIDPTR) pDest);
}
BOOL QSQL_DEF::InitVarsDialog /* ---- Init Variables Dialog ----------- */
( HWND hDlg, // window handle
OBJECTID qsqlObj // qsql object
)
/* Inits Variables group box. */
{ MemBlock mb; // memblock class
WORD varCount; // number of VARs
Var huge *varPtr; // VAR pointer
int extNameLen; // extended name length
char extName[EXTNAMESIZE]; // extended name
long typeIdx; // type index
TYPEID type; // type
char name[MXVARSIZE];// name
WORD i; // counter
AUtlCenterDialog(hDlg, 0);
SetWindowLong(hDlg, DWL_USER, (DWORD) qsqlObj); // saves object id
varCount = (WORD) (AObjGetDataSize(qsqlObj, QSQLVARS) / sizeof(Var));
varPtr = (Var *) mb.GetPointer(qsqlObj, QSQLVARS);
/* ---- inits variable ---- */
for (i = 0; i < varCount; i++, varPtr++)
{ if (varPtr->obj && !AObjCheckType(varPtr->obj, 0))
varPtr->obj = 0;
extNameLen = (int) hstrlen(varPtr->name);
hmemcpy(extName, varPtr->name, extNameLen);
if (varPtr->obj)
{ lstrcpy(&extName[extNameLen], ": <");
ATypeGetName(varPtr->type, &extName[extNameLen + 3], sizeof(name));
lstrcat(&extName[extNameLen], ">");
} // if
else
lstrcpy(&extName[extNameLen], ": <(None)>");
SendDlgItemMessage(hDlg, IDL_VARS, LB_INSERTSTRING, i, (DWORD) extName);
SendDlgItemMessage(hDlg, IDL_VARS, LB_SETITEMDATA,
i, (DWORD) varPtr->obj);
} // for
/* inserts an empty mask */
SendDlgItemMessage(hDlg, IDL_VARS, LB_INSERTSTRING, i, (DWORD) "");
SendDlgItemMessage(hDlg, IDL_VARS, LB_SETITEMDATA, i, 0);
/* ---- inits type ---- */
i = SendDlgItemMessage(hDlg, IDC_TYPE, CB_INSERTSTRING,
-1, (DWORD) "(None)");
SendDlgItemMessage(hDlg, IDC_TYPE, CB_SETITEMDATA, i, 0);
typeIdx = AOBJ_GETFIRSTKEY;
while ((type = ATypeGetNext(&typeIdx)) != 0)
if (type == OTYPE_TEXT || type == OTYPE_NUMBER ||
type == OTYPE_DATE || type == OTYPE_TIME)
{ ATypeGetName(type, name, sizeof(name));
i = SendDlgItemMessage(hDlg, IDC_TYPE, CB_INSERTSTRING,
-1, (DWORD) name);
SendDlgItemMessage(hDlg, IDC_TYPE, CB_SETITEMDATA, i, (DWORD) type);
} // if
return TRUE;
} // InitVars
void
_TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
{
if (c > 0xFFFF)
hmemcpy((void _huge*) d, (void _huge*) s, c);
else
(void) memcpy(d, s, (size_t) c);
}
//************************************************************************
BOOL CDib::Create( PDIB pdib )
//************************************************************************
{
DWORD dwSizeImage;
dwSizeImage = pdib->GetSizeImage();
if ( !(m_lp = AllocX( dwSizeImage + 1024, GMEM_ZEROINIT )) )
{
return FALSE;
}
m_bmiHeader = *pdib->GetInfoHeader();
hmemcpy( m_rgbQuad, pdib->GetColors(), sizeof(m_rgbQuad));
hmemcpy(m_lp, pdib->GetPtr(), pdib->GetSizeImage());
return TRUE;
}
//************************************************************************
CDib::CDib(LPBITMAPINFOHEADER lpbmiHeader, LPRGBQUAD lpColors, LPTR lp)
//************************************************************************
{
m_bmiHeader = *lpbmiHeader;
hmemcpy( m_rgbQuad, lpColors, sizeof(m_rgbQuad));
m_lp = lp;
m_iRefCount = 0;
AddRef();
}
BOOL CDib::DibFlip()
{
UINT cLine = GetHeight();
UINT cFlip = cLine / 2;
long cbLine = GetWidthBytes();
UINT i;
HPTR lpTop, lpBottom, lpTemp;
static BYTE temp[640];
if (cLine >= 2)
{
if (cbLine > 640)
{
if ((lpTemp = (HPTR)GlobalAllocPtr(GHND, cbLine)) == NULL)
return FALSE;
}
else
{
lpTemp = &temp[0];
}
lpTop = GetPtr();
lpBottom = lpTop + (cLine - 1) * cbLine;
for (i = 0 ; i < cFlip ; i++)
{
if (lpBottom < lpTop)
return FALSE;
hmemcpy(lpTemp, lpTop, cbLine);
hmemcpy(lpTop, lpBottom, cbLine);
hmemcpy(lpBottom, lpTemp, cbLine);
lpTop += cbLine;
lpBottom -= cbLine;
}
if (lpTemp != &temp[0])
GlobalFreePtr(lpTemp);
}
m_bmiHeader.biHeight = -m_bmiHeader.biHeight;
return TRUE;
}
void TABLE::tPaste()
{
if(TABLE_ATTRIBUTES::AutoFill())
return;
BOOL available = IsClipboardFormatAvailable(CF_TEXT);
if(!available)
return;
DestroyAllEditControls();
OpenClipboard(hParentWnd);
HGLOBAL hClipboard = GetClipboardData(CF_TEXT);
if(!hClipboard)
{
CloseClipboard();
return;
}
HGLOBAL hCopy = GlobalAlloc(GHND, GlobalSize(hClipboard));
if(!hCopy)
{
CloseClipboard();
return;
}
char* copy = (char*)GlobalLock(hCopy);
char* clip = (char*)GlobalLock(hClipboard);
hmemcpy(copy, clip, GlobalSize(hClipboard));
GlobalUnlock(hClipboard);
CloseClipboard();
RUNTIMEINFO* rtime = (RUNTIMEINFO*)AObjGetRuntimeInfo(theObject);
ROW* row = rtime->GetRow();
long first = row->FirstSelection();
char* token = (char*)myStrtok((char huge*)copy);
while(token)
{
row->AddRow(first, token, TABLE_ATTRIBUTES::NumColumns(), FALSE);
token = (char*)myStrtok(NULL);
first++;
}
GlobalUnlock(hCopy);
GlobalFree(hCopy);
row->DeleteSelectedRows();
PostObjectChanged(CHANGED_NUMROWS);
}
void crypto777_encrypt(HUFF *dest,HUFF *src,int32_t len,struct crypto777_user *sender,uint32_t timestamp)
{
bits256 hash; bits384 xorpad; int32_t i; uint64_t *ptr = (uint64_t *)src->buf;
hseek(dest,len << 3,SEEK_SET), hrewind(dest), hseek(src,len << 3,SEEK_SET), hrewind(src);
calc_sha256cat(hash.bytes,(uint8_t *)&sender->nxt64bits,sizeof(sender->nxt64bits),(uint8_t *)×tamp,sizeof(timestamp));
SaM_Initialize(&sender->XORpad);
SaM_Absorb(&sender->XORpad,hash.bytes,sizeof(hash.bytes),sender->shared_SaM.bytes,sizeof(sender->shared_SaM));
while ( len >= sizeof(xorpad) )
{
SaM_emit(&sender->XORpad);
for (i=0; i<6; i++)
xorpad.ulongs[i] = (sender->XORpad.bits.ulongs[i] ^ ptr[i]);//, printf("%llx ",(long long)xorpad.ulongs[i]);
ptr += 6;
hmemcpy(0,xorpad.bytes,dest,sizeof(xorpad)), len -= sizeof(xorpad);
}
if ( len > 0 )
{
SaM_emit(&sender->XORpad);
for (i=0; i<len; i++)
xorpad.bytes[i] = (sender->XORpad.bits.bytes[i] ^ ((uint8_t *)ptr)[i]);//, printf("%2x ",xorpad.bytes[i]);
hmemcpy(0,xorpad.bytes,dest,len), len -= sizeof(xorpad);
}
//printf(" dest %llu\n",(long long)sender->nxt64bits);
}
//
// Clone DataObject only for MOVE/COPY operation
//
HRESULT CDS_IDLData_Clone(LPDATAOBJECT pdtobjIn, UINT acf[], UINT ccf, LPDATAOBJECT *ppdtobjOut)
{
HRESULT hres = CDS_IDLData_CreateInstance(NULL, ppdtobjOut, NULL);
if (SUCCEEDED(hres))
{
UINT i;
FORMATETC fmte = { 0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
for (i=0 ; i<ccf ; i++)
{
HRESULT hresT;
STGMEDIUM medium;
fmte.cfFormat = acf[i];
hresT = pdtobjIn->lpVtbl->GetData(pdtobjIn, &fmte, &medium);
if (SUCCEEDED(hresT))
{
HGLOBAL hmem;
if (medium.pUnkForRelease)
{
// We need to clone the hGlobal.
UINT cbMem = GlobalSize(medium.hGlobal);
hmem = GlobalAlloc(GPTR, cbMem);
if (hmem)
{
hmemcpy((LPVOID)hmem, GlobalLock(medium.hGlobal), cbMem);
GlobalUnlock(medium.hGlobal);
}
SHReleaseStgMedium(&medium);
}
else
{
// We don't need to clone the hGlobal.
hmem = medium.hGlobal;
}
if (hmem)
DataObj_SetGlobal(*ppdtobjOut, acf[i], hmem);
}
}
}
return hres;
}
long UPSF::xxxx_To_xxxx(
HGLOBAL& hUniv,
long& univSize,
void* natvPtr,
long natvLen)
{
univSize = natvLen;
if((hUniv = GlobalReAlloc(hUniv, natvLen, MEMFLAGS))==NULL)
return AUPSF_MEMORYERROR;
void* univPtr = GlobalLock(hUniv);
if(!univPtr)
return AUPSF_MEMORYERROR;
hmemcpy(univPtr, natvPtr, natvLen);
GlobalUnlock(hUniv);
return AUPSF_NOERROR;
}
Handle DupHandle(Handle oldhand)
{
LPSTR newptr, oldptr;
Handle newhand;
size_t size;
oldptr = *oldhand; // ptr to actual data
size = WSizeBuffer(oldptr);
newhand = NewHandle(Convert_size_t_to_int(size));
newptr = *newhand;
#ifdef WIN32
memcpy(newptr, oldptr, size);
#else
hmemcpy(newptr, oldptr, size);
#endif
return newhand;
}
long UPSF::BitmapInfo_To_UBit(
HGLOBAL& hUniv,
long& univSize,
void* natvPtr,
long natvLen)
{
// this windows bitmap format is the UPSF bitmap format
univSize = natvLen;
if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))
return AUPSF_MEMORYERROR;
void* univPtr = GlobalLock(hUniv);
if(!univPtr)
return AUPSF_MEMORYERROR;
hmemcpy(univPtr, natvPtr, natvLen);
GlobalUnlock(hUniv);
return AUPSF_NOERROR;
}
long UPSF::DWord_To_UNum(
HGLOBAL& hUniv,
long& univSize,
DWORD dword)
{
char szBuffer[80];
sprintf(szBuffer, "%lu", dword);
univSize = strlen(szBuffer);
if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))
return AUPSF_MEMORYERROR;
void* univPtr = GlobalLock(hUniv);
if(!univPtr)
return AUPSF_MEMORYERROR;
hmemcpy(univPtr, szBuffer, univSize);
GlobalUnlock(hUniv);
return AUPSF_NOERROR;
}
long UPSF::LDouble_To_UNum(
HGLOBAL& hUniv,
long& univSize,
long double LDouble)
{
char szBuffer[80];
sprintf(szBuffer, "%.20Lg", LDouble);
univSize = strlen(szBuffer);
if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))
return AUPSF_MEMORYERROR;
void* univPtr = GlobalLock(hUniv);
if(!univPtr)
return AUPSF_MEMORYERROR;
hmemcpy(univPtr, szBuffer, univSize);
GlobalUnlock(hUniv);
return AUPSF_NOERROR;
}
LPVOID DSDataObj_SaveToMemory(IDataObject *pdtobj, UINT cntFmt, UINT fmts[], BOOL fShared)
{
MEM_CRAP *pmem = NULL; // assume error
UINT cbDataSize = 0;
UINT iNumFormats = 0;
UINT i;
if (!ISIDLDATA(pdtobj))
return NULL;
for (i = 0; i < cntFmt; i++)
{
STGMEDIUM medium;
FORMATETC fmte = {fmts[i], NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
if (SUCCEEDED(pdtobj->lpVtbl->GetData(pdtobj, &fmte, &medium)))
{
cbDataSize += GlobalSize(medium.hGlobal);
iNumFormats++;
SHReleaseStgMedium(&medium);
}
}
if (cbDataSize)
{
UINT cbTotal = SIZEOF(MEM_CRAP) +
(iNumFormats * SIZEOF(UINT) * 2) + // cfFormat, cbFormat
cbDataSize;
pmem = fShared ? Alloc(cbTotal) : GlobalAlloc(GPTR, cbTotal);
if (pmem)
{
UNALIGNED UINT *pdata = (UNALIGNED UINT *)((LPBYTE)pmem + SIZEOF(MEM_CRAP));
pmem->iNumFormats = iNumFormats;
// ultra cool HACK....
pmem->offVtbl = (ULONG)pdtobj->lpVtbl - (ULONG)&c_CDS_IDLDataVtbl;
for (i = 0; i < cntFmt; i++)
{
STGMEDIUM medium;
FORMATETC fmte = {fmts[i], NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
if (SUCCEEDED(pdtobj->lpVtbl->GetData(pdtobj, &fmte, &medium)))
{
UINT cbData = GlobalSize(medium.hGlobal);
*pdata++ = fmts[i];
*pdata++ = cbData;
hmemcpy(pdata, (LPVOID)medium.hGlobal, cbData);
pdata = (UNALIGNED UINT *)((LPBYTE)pdata + cbData);
SHReleaseStgMedium(&medium);
Assert(((UINT)pdata - (UINT)pmem) <= cbTotal);
}
}
}
}
return pmem;
}
BOOL ClipboardCopy(void)
{ HGLOBAL hMem;
char huge *pMem;
LONG lSize;
BOOL WideCharConvert = FALSE;
UINT Codepage = 0;
/*prepare resources...*/
if (!SelectCount) {
Error(209);
return (FALSE);
}
if (!OpenClipboard(hwndMain)) {
ErrorBox(MB_ICONEXCLAMATION, 302);
return (FALSE);
}
lSize = SelectCount + sizeof(BinaryPart);
if (!(GetVersion() & 0x80000000U))
if (UtfEncoding || CharSet == CS_OEM || AnsiCodePage != CP_ACP) {
/*copy as wide chars...*/
Codepage = CharSet == CS_OEM ? OemCodePage : AnsiCodePage;
if (UtfEncoding != 16)
lSize <<= 1;
WideCharConvert = TRUE;
}
hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, lSize);
if (!hMem) {
CloseClipboard();
ErrorBox(MB_ICONEXCLAMATION, 304);
return (FALSE);
}
pMem = GlobalLock(hMem);
if (pMem == NULL) {
CloseClipboard();
GlobalFree(hMem);
ErrorBox(MB_ICONEXCLAMATION, 305);
return (FALSE);
}
/*copy into memory...*/
{ POSITION Pos;
ULONG Bytes = SelectCount;
UINT i;
BOOL NullbyteFound = FALSE;
Pos = SelectStart;
if (UtfEncoding && WideCharConvert) {
POSITION EndPos = Pos;
WCHAR *pw = (WCHAR *)pMem;
Advance(&EndPos, Bytes);
//if (CountBytes(&Pos) != 0 || (i = CharAndAdvance(&Pos)) == C_BOM)
i = CharAndAdvance(&Pos);
for (;;) {
if (ComparePos(&Pos, &EndPos) > 0)
break;
if (i == C_EOF) break;
if (i == C_CRLF) {
if ((char *)pw + 6 > pMem + lSize)
break;
*pw++ = '\r';
i = '\n';
}
if ((char *)pw + 4 > pMem + lSize)
break;
*pw++ = i;
i = CharAndAdvance(&Pos);
}
*pw = '\0';
} else while (Bytes) {
LPSTR p, pNull;
CharAt(&Pos); /*normalize position and enforce page load*/
i = Pos.p->Fill - Pos.i;
if (i > Bytes) i = (UINT)Bytes;
p = Pos.p->PageBuf + Pos.i;
if (!NullbyteFound && (pNull = _fmemchr(p, '\0', i)) != NULL) {
if (ErrorBox(MB_ICONINFORMATION|MB_OKCANCEL, 328) == IDCANCEL) {
CloseClipboard();
GlobalUnlock(hMem);
GlobalFree(hMem);
return (FALSE);
}
NullbyteFound = TRUE;
i = pNull - p + 1;
if (CharSet == CS_EBCDIC) EbcdicConvert(pMem, p, i);
else if (WideCharConvert) {
MultiByteToWideChar(Codepage, 0, p, i, (WCHAR*)pMem, i);
pMem += i;
} else hmemcpy(pMem, p, i);
pMem += i;
Bytes -= --i;
Pos.i += i;
i = wsprintf(BinaryPart, BinaryFormat, Bytes);
if (WideCharConvert) {
MultiByteToWideChar(Codepage, 0, BinaryPart, i,
(WCHAR*)pMem, i);
pMem += i;
} else hmemcpy(pMem, BinaryPart, i);
pMem += i;
continue;
}
if (CharSet == CS_EBCDIC)
EbcdicConvert(pMem, Pos.p->PageBuf + Pos.i, i);
else if (WideCharConvert) {
MultiByteToWideChar(Codepage, 0, Pos.p->PageBuf + Pos.i, i,
(WCHAR*)pMem, i);
if (CharSet == CS_OEM) {
extern WCHAR const MapLowOemToUtf16[33];
PWSTR pw = (WCHAR*)pMem;
INT j;
for (j=i; j>0; --j) {
if (*pw < ' ') {
switch (*pw) {
case '\0':
case '\t':
case '\n':
case '\r': break;
default: *pw = MapLowOemToUtf16[*pw];
}
}
++pw;
}
}
pMem += i;
} else hmemcpy(pMem, Pos.p->PageBuf + Pos.i, i);
pMem += i;
Bytes -= i;
Pos.i += i;
}
}
/*unlock...*/
GlobalUnlock(hMem);
/*clear previous clipboard contents...*/
if (!EmptyClipboard()) {
CloseClipboard();
GlobalFree(hMem);
ErrorBox(MB_ICONEXCLAMATION, 303);
return (FALSE);
}
/*finally, publish...*/
SetClipboardData(WideCharConvert ? CF_UNICODETEXT
: CharSet == CS_OEM ? CF_OEMTEXT
: CF_TEXT, hMem);
CloseClipboard();
CheckClipboard();
return (TRUE);
}
// Note we only support 8bpp DIBs here, and..
// there is no regard for color table matching between the DIBs
//************************************************************************
void CDib::DibBlt(PDIB pdibDst, int dstLeft, int dstTop, int dstWidth, int dstHeight,
int srcLeft, int srcTop, int srcWidth, int srcHeight,
BOOL bTransparent, LPRGBTRIPLE lpRGB, LPTR lpLut, HPALETTE hPal )
//************************************************************************
{
HPTR pSrc, pDst;
int iScanS, iScanD, iOverrun;
if ( !pdibDst )
return;
if ( GetBitCount() != 8 )
return;
if ( pdibDst->GetBitCount() != 8 )
return;
// Check the coordinate bounds, to avoid an out of range pointer
if ( srcLeft < 0 ) { dstLeft -= srcLeft; srcWidth += srcLeft; dstWidth += srcLeft; srcLeft = 0; }
if ( srcTop < 0 ) { dstTop -= srcTop; srcHeight += srcTop; dstHeight += srcTop; srcTop = 0; }
if ( dstLeft < 0 ) { srcLeft -= dstLeft; srcWidth += dstLeft; dstWidth += dstLeft; dstLeft = 0; }
if ( dstTop < 0 ) { srcTop -= dstTop; srcHeight += dstTop; dstHeight += dstTop; dstTop = 0; }
if ( srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0 )
return;
if ( srcLeft - GetWidth() >= 0 ) return;
if ( srcTop - abs(GetHeight()) >= 0 ) return;
if ( dstLeft - pdibDst->GetWidth() >= 0 ) return;
if ( dstTop - abs(pdibDst->GetHeight()) >= 0 ) return;
if ( (iOverrun = srcLeft + srcWidth - GetWidth()) > 0 ) { srcWidth -= iOverrun; dstWidth -= iOverrun; }
if ( (iOverrun = srcTop + srcHeight - abs(GetHeight())) > 0 ) { srcHeight -= iOverrun; dstHeight -= iOverrun; }
if ( (iOverrun = dstLeft + dstWidth - pdibDst->GetWidth()) > 0 ) { dstWidth -= iOverrun; srcWidth -= iOverrun; }
if ( (iOverrun = dstTop + dstHeight - abs(pdibDst->GetHeight())) > 0 ) { dstHeight -= iOverrun; srcHeight -= iOverrun; }
if ( srcWidth <= 0 || srcHeight <= 0 || dstWidth <= 0 || dstHeight <= 0 )
return;
// Get pointers to the start points in the source and destination
if ( !(pSrc = GetXY( srcLeft, srcTop )) )
return;
if ( !(pDst = pdibDst->GetXY( dstLeft, dstTop )) )
return;
// Get the scan line widths of each DIB.
iScanS = GetWidthBytes();
iScanD = pdibDst->GetWidthBytes();
// Upside down DIBs have to move backwards
if ( GetHeight() > 0 )
iScanS = -iScanS;
if ( pdibDst->GetHeight() > 0 )
iScanD = -iScanD;
if ( !bTransparent )
{ // Copy the lines.
while ( --srcHeight >= 0 )
{
hmemcpy( pDst, pSrc, srcWidth );
pSrc += iScanS;
pDst += iScanD;
}
}
else
if (lpRGB)
{ // Copy lines with transparency mask
WORD src, dst, wMini;
BYTE dstPixel, srcColor, red, green, blue;
int iSinc, iDinc, iCount;
LPRGBQUAD pTable = GetColors();
if (lpLut)
{
wMini = RGB3toMiniRGB(lpRGB->rgbtRed, lpRGB->rgbtGreen, lpRGB->rgbtBlue);
srcColor = lpLut[wMini];
}
else
if (hPal)
{
srcColor = (BYTE)GetNearestPaletteIndex( hPal, RGB(lpRGB->rgbtRed, lpRGB->rgbtGreen, lpRGB->rgbtBlue) );
}
else
srcColor = 0;
iSinc = iScanS - srcWidth; // Source increment value
iDinc = iScanD - srcWidth; // Destination increment value
while ( --srcHeight >= 0 )
{
iCount = srcWidth; // Number of pixels to scan.
while ( --iCount >= 0 )
{
src = (WORD)(*pSrc++);
// Copy pixel only if it isn't transparent.
if (src == 0)
pDst++;
else
if (src == 255)
*pDst++ = srcColor;
else
{
if (src > 127)
++src;
dst = 256-src;
dstPixel = *pDst;
red = (BYTE)((((WORD)lpRGB->rgbtRed * src) + ((WORD)pTable[dstPixel].rgbRed * dst)) >> 8);
green = (BYTE)((((WORD)lpRGB->rgbtGreen * src) + ((WORD)pTable[dstPixel].rgbGreen * dst)) >> 8);
blue = (BYTE)((((WORD)lpRGB->rgbtBlue * src) + ((WORD)pTable[dstPixel].rgbBlue * dst)) >> 8);
if (lpLut)
{
wMini = RGB3toMiniRGB(red, green, blue);
*pDst++ = lpLut[wMini];
}
else
if (hPal)
{
*pDst++ = (BYTE)GetNearestPaletteIndex( hPal, RGB(red, green, blue) );
}
else
{
pDst++;
}
}
}
pSrc += iSinc;
pDst += iDinc;
}
}
else
{ // Copy lines with transparency.
BOOL RleFile_Init(RLEFILE *prle, LPVOID pFile, HANDLE hRes, DWORD dwFileLen)
{
UNALIGNED DWORD PTR *pdw;
UNALIGNED DWORD PTR *pdwEnd;
DWORD dwRiff;
DWORD dwType;
DWORD dwLength;
int stream;
if (prle->pFile == pFile)
return TRUE;
RleFile_Close(prle);
prle->pFile = pFile;
prle->hRes = hRes;
if (prle->pFile == NULL)
return FALSE;
//
// now that the file is in memory walk the memory image filling in
// interesting stuff.
//
pdw = (UNALIGNED DWORD PTR *)prle->pFile;
dwRiff = *pdw++;
dwLength = *pdw++;
dwType = *pdw++;
if ((dwFileLen > 0) && (dwLength > dwFileLen)) {
// File is physically shorter than the length written in its header.
// Can't handle it.
goto exit;
}
if (dwRiff != mmioFOURCC('R', 'I', 'F', 'F'))
goto exit; // not even a RIFF file
if (dwType != formtypeAVI)
goto exit; // not a AVI file
pdwEnd = (DWORD PTR *)((BYTE PTR *)pdw + dwLength-4);
stream = 0;
while (pdw < pdwEnd)
{
dwType = *pdw++;
dwLength = *pdw++;
switch (dwType)
{
case mmioFOURCC('L', 'I', 'S', 'T'):
dwType = *pdw++;
dwLength -= 4;
switch (dwType)
{
case listtypeAVIMOVIE:
prle->pMovie = (LPVOID)pdw;
break;
case listtypeSTREAMHEADER:
case listtypeAVIHEADER:
dwLength = 0; // decend
break;
default:
break; // ignore
}
break;
case ckidAVIMAINHDR:
prle->pMainHeader = (MainAVIHeader PTR *)pdw;
prle->NumFrames = (int)prle->pMainHeader->dwTotalFrames;
prle->Width = (int)prle->pMainHeader->dwWidth;
prle->Height = (int)prle->pMainHeader->dwHeight;
prle->Rate = (int)(prle->pMainHeader->dwMicroSecPerFrame/1000);
if (prle->pMainHeader->dwInitialFrames != 0)
goto exit;
if (prle->pMainHeader->dwStreams > 2)
goto exit;
break;
case ckidSTREAMHEADER:
stream++;
if (prle->pStream != NULL)
break;
if (((AVIStreamHeader PTR *)pdw)->fccType != streamtypeVIDEO)
break;
prle->iStream = stream-1;
prle->pStream = (AVIStreamHeader PTR*)pdw;
if (prle->pStream->dwFlags & AVISF_VIDEO_PALCHANGES)
goto exit;
break;
case ckidSTREAMFORMAT:
if (prle->pFormat != NULL)
break;
if (prle->pStream == NULL)
break;
prle->pFormat = (LPBITMAPINFOHEADER)pdw;
if (prle->pFormat->biSize != sizeof(BITMAPINFOHEADER))
goto exit;
if (prle->pFormat->biCompression != 0 &&
prle->pFormat->biCompression != BI_RLE8)
goto exit;
if (prle->pFormat->biWidth != prle->Width)
goto exit;
if (prle->pFormat->biHeight != prle->Height)
goto exit;
hmemcpy(&prle->bi, prle->pFormat, dwLength);
prle->bi.biSizeImage = 0;
prle->FullSizeImage = ((prle->bi.biWidth * prle->bi.biBitCount + 31) & ~31)/8 * prle->bi.biHeight;
break;
case ckidAVINEWINDEX:
prle->pIndex = (AVIINDEXENTRY PTR *)pdw;
break;
}
pdw = (DWORD PTR *)((BYTE PTR *)pdw + ((dwLength+1)&~1));
}
//
// if the file has nothing in it we care about get out, note
// we dont need a index, we do need some data though.
//
if (prle->NumFrames == 0 ||
prle->pMainHeader == NULL ||
prle->pStream == NULL ||
prle->pFormat == NULL ||
prle->pMovie == NULL )
{
goto exit;
}
//
// if we cared about a palette we would create it here.
//
//
// file open'ed ok seek to the first frame.
//
prle->iFrame = -42;
RleFile_Seek(prle, 0);
return TRUE;
exit:
RleFile_Close(prle);
return FALSE;
}
/* -------------------------------------------------------------------- */
void slidemsgTab(int howmany)
{
hmemcpy(&msgTab[howmany], &msgTab[0],(long)
((long)( (long)cfg.nmessages - (long)howmany) * (long)(sizeof(*msgTab)) )
);
}
BOOL EnterDeleteForUndo(PPOSITION Pos, ULONG Length, WORD Flags)
/*Flags: 1=enter as selected, reselect after undo
* 2=remove last undo information, cannot be undone later
*/
{ LPBYTE NewBuf = NULL;
HGLOBAL NewMem = 0;
POSITION p;
ULONG Inx;
ULONG ByteCount = CountBytes(Pos);
ULONG OldSize;
LPUNDO Reallocated = NULL;
if (Flags & 2) {
if (!LastUndo->Inserted) return (FALSE);
--LastUndo->Inserted;
return (TRUE);
}
CheckForUndoneToRelease(TRUE);
EnableUndo();
if (!LastUndo ||
(LastUndo->Pos != (ULONG)-1
&& (LastUndo->Pos != ByteCount - LastUndo->Inserted
|| (int)(Flags & 1) != ((LastUndo->Flags & UD_SELECT) != 0)
|| !(LastUndo->Flags & UD_GLOBALMEM
&& LastUndo->DelFill+Length > 64000))))
if (!NewUndo()) return (FALSE);
if (LastUndo->Pos == (ULONG)-1) LastUndo->Pos = ByteCount;
if (!LastUndo->DelFill) {
OldSize = 0;
if (Length > 64000) {
LastUndo->Flags |= UD_GLOBALMEM;
NewMem = GlobalAlloc(GMEM_MOVEABLE, Length);
if (NewMem) NewBuf = GlobalLock(NewMem);
} else {
assert(!(LastUndo->Flags & UD_GLOBALMEM));
LastUndo->Flags &= ~UD_GLOBALMEM;
Reallocated = (LPUNDO)_frealloc(LastUndo,
(size_t)(sizeof(UNDO)+Length));
if (Reallocated == NULL) return (FALSE);
NewBuf = (LPBYTE)Reallocated + sizeof(UNDO);
}
} else {
if (LastUndo->Flags & UD_GLOBALMEM) {
OldSize = GlobalSize(LastUndo->DelMem);
if (LastUndo->DelFill + Length > OldSize) {
NewMem = GlobalReAlloc(LastUndo->DelMem,
LastUndo->DelFill + Length,
GMEM_MOVEABLE);
} else NewMem = LastUndo->DelMem;
if (NewMem) NewBuf = GlobalLock(NewMem);
} else {
Reallocated = (LPUNDO)_frealloc(LastUndo,
(size_t)(sizeof(UNDO) + Length
+ LastUndo->DelFill));
if (Reallocated == NULL) return (FALSE);
NewBuf = (LPBYTE)Reallocated + sizeof(UNDO);
OldSize = 0;
}
}
UndoMemUsed -= OldSize;
if (NewBuf == NULL) {
if (NewMem) GlobalFree(NewMem);
return (FALSE);
}
if (Reallocated!=NULL && Reallocated!=LastUndo) {
/*correct any references to this object...*/
if (NextSequenceUndo == LastUndo) NextSequenceUndo = Reallocated;
if (Reallocated->Prev != NULL) Reallocated->Prev->Next = Reallocated;
if (FirstUndo == LastUndo) FirstUndo = Reallocated;
LastUndo = Reallocated;
}
Inx = LastUndo->DelFill;
if (NewMem) {
UndoMemUsed += GlobalSize(NewMem);
LastUndo->DelMem = NewMem;
} else UndoMemUsed += Length;
LastUndo->DelFill += Length;
if (Flags & 1) LastUndo->Flags |= UD_SELECT;
p = *Pos;
while (Length) {
UINT n, c = CharAt(&p);
if (c == C_EOF) {
/*should not occur!...*/
assert(c != C_EOF); /*!?*/
LastUndo->DelFill -= Length;
break;
}
if (Length > p.p->Fill - p.i) n = p.p->Fill - p.i;
else n = (UINT)Length;
assert(p.p->PageBuf);
assert(n > 0);
assert(n <= PAGESIZE);
assert(p.i+n <= PAGESIZE);
hmemcpy(NewBuf + Inx, p.p->PageBuf + p.i, n);
Inx += n;
p.i += n;
Length -= n;
}
if (NewMem) GlobalUnlock(NewMem);
return (TRUE);
}
BOOL CWindowsMetaFile::GetMetaFile(HINSTANCE hInstance, LPCSTR pszResource, LPCSTR pszType, ALDUS_WMF_HEADER* pAldusHeader, METAHEADER* pHeader, HMETAFILE* phMetaFile)
{
BOOL fSuccess = FALSE;
ASSERT(hInstance != NULL);
ASSERT(pszResource != NULL);
ASSERT(pszType != NULL);
HRSRC hrResource;
hrResource = FindResource(hInstance, pszResource, pszType);
if (hrResource != NULL)
{
HGLOBAL hResource;
hResource = LoadResource(hInstance, hrResource);
if (hResource != NULL)
{
LPBYTE pResource;
#ifdef WIN32
DWORD dwGlobalSize = 0;
#else
DWORD dwGlobalSize = GlobalSize(hResource);
#endif
pResource = (LPBYTE)LockResource(hResource);
if (pResource != NULL)
{
ASSERT((dwGlobalSize == 0) || (dwGlobalSize >= sizeof(ALDUS_WMF_HEADER)+sizeof(METAHEADER)));
if ((dwGlobalSize == 0) || (dwGlobalSize >= sizeof(ALDUS_WMF_HEADER)+sizeof(METAHEADER)))
{
// Save the Aldus header if the user has requested it.
if (pAldusHeader != NULL)
{
*pAldusHeader = *((ALDUS_WMF_HEADER*)pResource);
}
// Validate the Aldus header.
if (((ALDUS_WMF_HEADER*)pResource)->key == ALDUS_WMF_KEY)
{
// Save the metafile header if the user has requested it.
if (pHeader != NULL)
{
*pHeader = *((METAHEADER*)(pResource+sizeof(ALDUS_WMF_HEADER)));
}
// Get the size from the metafile header.
DWORD dwSize = ((METAHEADER*)(pResource+sizeof(ALDUS_WMF_HEADER)))->mtSize*2;
if (dwGlobalSize != 0 && dwGlobalSize < sizeof(ALDUS_WMF_HEADER)+dwSize)
{
// This can be cause by the WMF files where mtSize includes the
// size of the Aldus header. Attempt to adjust for this by
// decreasing mtSize.
dwSize -= sizeof(ALDUS_WMF_HEADER);
}
if (dwSize != 0)
{
ASSERT((dwGlobalSize == 0) || (dwGlobalSize >= sizeof(ALDUS_WMF_HEADER)+dwSize));
if ((dwGlobalSize == 0) || (dwGlobalSize >= sizeof(ALDUS_WMF_HEADER)+dwSize))
{
// If the user wants a metafile handle, continue.
// Otherwise, return TRUE.
fSuccess = phMetaFile == NULL;
if (!fSuccess)
{
*phMetaFile = NULL;
// Allocate the memory to hold the metafile data.
HGLOBAL hMetaFileData;
hMetaFileData = GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE, dwSize);
if (hMetaFileData != NULL)
{
LPVOID pMetaFileData;
pMetaFileData = GlobalLock(hMetaFileData);
if (pMetaFileData != NULL)
{
// Copy the meta file data from the resource into the new memory block.
// We have now read the data, make a metafile from it.
#ifdef WIN32
memcpy(pMetaFileData, (LPVOID)(pResource+sizeof(ALDUS_WMF_HEADER)), dwSize);
*phMetaFile = ::SetMetaFileBitsEx(dwSize, (LPBYTE)pMetaFileData);
GlobalUnlock(hMetaFileData);
pMetaFileData = NULL;
#else
hmemcpy(pMetaFileData, (LPVOID)(pResource+sizeof(ALDUS_WMF_HEADER)), dwSize);
*phMetaFile = ::SetMetaFileBits(hMetaFileData);
if (*phMetaFile == NULL)
{
GlobalUnlock(hMetaFileData);
pMetaFileData = NULL;
}
#endif
fSuccess = *phMetaFile != NULL;
}
#ifdef WIN32
GlobalFree(hMetaFileData);
hMetaFileData = NULL;
#else
if (*phMetaFile == NULL)
{
GlobalFree(hMetaFileData);
hMetaFileData = NULL;
}
#endif
}
}
}
}
}
}
GlobalUnlock(hResource);
pResource = NULL;
}
FreeResource(hResource);
hResource = NULL;
}
}
return fSuccess;
}
ERRORCODE MemoryDevice::read(LPVOID ptr, ST_DEV_IO_SIZE size, ST_DEV_IO_SIZE *size_read /*=NULL*/)
{
if (m_Position < 0 || m_Position >= m_Length)
{
if (size_read != NULL)
{
*size_read = 0;
return ERRORCODE_None;
}
/* Can't read from here. */
return ERRORCODE_Read;
}
ST_DEV_POSITION Size = (ST_DEV_POSITION)size;
if (m_Position + Size > m_Length)
{
if (size_read == NULL)
{
// Just not enough data to even try.
return ERRORCODE_Read;
}
Size = m_Length - m_Position;
}
int nBlocks = m_Pieces.count();
ST_DEV_IO_SIZE AmountRead = 0; // How much we actually have read.
/*
// Prep to search for blocks.
// If we do any block "remembering", we can do it here to start further on.
*/
int nBlock = 0;
MEMORY_DEVICE_PIECE* pPiece = NULL;
/*
// Find the block the data starts in.
*/
for (; nBlock < nBlocks; nBlock++)
{
pPiece = (MEMORY_DEVICE_PIECE*)m_Pieces.get_element(nBlock);
if (pPiece->m_Start + pPiece->m_lSize > m_Position)
{
break;
}
}
if (nBlock == nBlocks)
{
return ERRORCODE_IntError;
}
/*
// Do the reading thing now.
*/
LPBYTE pDest = (LPBYTE)ptr;
while (Size != 0)
{
// Compute how far into this block we need to start reading.
ST_DEV_POSITION Offset = m_Position - pPiece->m_Start;
// Compute how much data is left in the block.
ST_DEV_POSITION ReadSize = pPiece->m_lSize - Offset;
if (ReadSize > Size)
{
ReadSize = Size;
}
#ifdef WIN32
BYTE* pData = (BYTE*)pPiece->m_pData;
#else
BYTE huge* pData = (BYTE huge*)pPiece->m_pData;
#endif
// Offset to data.
pData += Offset;
// Do the copy.
#ifdef WIN32
memcpy(pDest, pData, ReadSize);
#else
hmemcpy(pDest, pData, ReadSize);
#endif
// Advance the destination pointer.
pDest += (int)ReadSize;
// Update the copy variables.
m_Position += ReadSize;
AmountRead += (ST_DEV_IO_SIZE)ReadSize;
if ((Size -= ReadSize) == 0)
{
break;
}
// Advance to the next block. This 'if' is a sanity check only.
if (++nBlock == nBlocks)
{
return ERRORCODE_IntError;
}
pPiece++;
}
/* Report how much we read if that is desired. */
if (size_read != NULL)
{
*size_read = AmountRead;
}
/* No errors to report. */
return ERRORCODE_None;
}
/******************************************************************************
* void OnNewWindow(HWND hwnd)
*
* Window/New Window menu item selected
*
* parameters:
* hwnd - window handle of active child window or NULL if none active
******************************************************************************/
static void OnNewWindow(HWND hwnd)
{
char sz[_MAX_PATH + 1];
MDICREATESTRUCT mcs;
CHILDINSTANCEDATA PICFAR* pInstance = ChildGetInstanceData(hwnd);
CHILDINSTANCEDATA PICFAR* pNew;
if ( pInstance == 0 )
return; /* Window/New Window should have been grayed */
pNew = (CHILDINSTANCEDATA PICFAR*)MiscGlobalAllocPtr(
sizeof(*pNew) + lstrlen(pInstance->pszFilename) + 1, IDS_NEWWINDOWOUTOFMEMORY);
/* "There was not enough memory to create the new window." */
if ( pNew == 0 )
return;
*pNew = *pInstance; /* this has the effect of duplicating the modified state
of the window as well as of duplicating the src picparm
Duplicating the src picparm this way works only because
we don't allocate comments, appfields, etc in the
pegasusquery picparm, so it's self-contained */
pNew->pszFilename = (LPSTR)pNew + sizeof(*pNew);
lstrcpy(pNew->pszFilename, pInstance->pszFilename);
pNew->xWindowOrg = 0; /* not scrolled to start out */
pNew->yWindowOrg = 0;
pNew->bRButtonDown = FALSE; /* should be FALSE anyway */
assert(!pInstance->bRButtonDown);
pNew->bLButtonDown = FALSE; /* should be FALSE anyway */
assert(!pInstance->bLButtonDown);
pNew->bDisableSetScrollRanges = FALSE; /* should be FALSE anyway */
assert(!pInstance->bDisableSetScrollRanges);
pNew->hPalette = NULL; /* this window will need its own hpalette */
pNew->nWaitCursor = 0;
assert(pInstance->nWaitCursor == 0);
/* duplicate the source image */
pNew->pSrc = MiscGlobalAllocPtr(pNew->dwSrcLen, IDS_NEWWINDOWOUTOFMEMORY);
/* "There was not enough memory to create the new window." */
if ( pNew->pSrc == 0 )
{
MiscGlobalFreePtr(&pInstance);
return;
}
hmemcpy(pNew->pSrc, pInstance->pSrc, pNew->dwSrcLen);
/* duplicate the dib unless it's a pointer into the source image */
if ( pInstance->pDib < pInstance->pSrc ||
pInstance->pDib >= pInstance->pSrc + pInstance->dwSrcLen )
{
pNew->pDib = MiscGlobalAllocPtr(pNew->dwDibLen, IDS_NEWWINDOWOUTOFMEMORY);
/* "There was not enough memory to create the new window." */
if ( pNew->pDib == 0 )
{
MiscGlobalFreePtr(&pNew->pSrc);
MiscGlobalFreePtr(&pInstance);
return;
}
hmemcpy(pNew->pDib, pInstance->pDib, pNew->dwDibLen);
}
else
pNew->pDib = pNew->pSrc + ( pInstance->pDib - pInstance->pSrc );
/* duplicate the dib picparm - through the opcode because there may be comments
or appfields or overtext or some such which need to be separately allocated,
and which only the opcode knows enough to allocate
if not implemented, then old is copied over new above when old instance is
copied to new instance */
if ( pNew->pOpenOp->pfnDupPicParm != 0 &&
!(*pNew->pOpenOp->pfnDupPicParm)(&pInstance->DibPicParm, &pNew->DibPicParm) )
{
(*pNew->pOpenOp->pfnCleanup)(pNew->pDib, 0, 0);
MiscGlobalFreePtr(&pNew->pSrc);
MiscGlobalFreePtr(&pInstance);
ErrorMessage(STYLE_ERROR, IDS_NEWWINDOWOUTOFMEMORY);
/* "There was not enough memory to create the new window." */
return;
}
/* duplicate image options settings */
if ( !CtrlDataDup(
(LPCTRLINITDATA)pInstance->pOpenData,
(LPCTRLINITDATA PICFAR *)&pNew->pOpenData) )
{
(*pNew->pOpenOp->pfnCleanup)(pNew->pDib, &pInstance->DibPicParm, 0);
MiscGlobalFreePtr(&pNew->pSrc);
MiscGlobalFreePtr(&pInstance);
ErrorMessage(STYLE_ERROR, IDS_NEWWINDOWOUTOFMEMORY);
/* "There was not enough memory to create the new window." */
return;
}
/* Create MDI child window */
GetWindowText(hwnd, sz, sizeof(sz));
mcs.szClass = MDICHILD_CLASSNAME;
mcs.szTitle = pInstance->pszFilename;
mcs.hOwner = hinstThis;
mcs.x = CW_USEDEFAULT;
mcs.y = CW_USEDEFAULT;
mcs.cx = CW_USEDEFAULT;
mcs.cy = CW_USEDEFAULT;
mcs.style = WS_HSCROLL | WS_VSCROLL;
mcs.lParam = (LPARAM)pNew;
if ( ChildGetActive() != NULL && IsZoomed(ChildGetActive()) )
mcs.style |= WS_MAXIMIZE;
// tell the MDI Client to create the child
LockWindowUpdate(hwndMDIClient);
hwnd = FORWARD_WM_MDICREATE(hwndMDIClient, (LPMDICREATESTRUCT)&mcs, SendMessage);
if ( hwnd == NULL )
{
LockWindowUpdate(NULL);
(*pNew->pOpenOp->pfnCleanup)(pNew->pDib, &pInstance->DibPicParm, pNew->pOpenData);
MiscGlobalFreePtr(&pNew->pSrc);
MiscGlobalFreePtr(&pInstance);
ErrorMessage(STYLE_ERROR, IDS_NEWWINDOWCREATE);
/* "An unexpected error occurred creating the new window." */
return;
}
ShowWindow(hwnd, SW_HIDE);
LockWindowUpdate(NULL);
UpdateWindow(hwndMDIClient);
/* make sure the window isn't bigger than the image */
ChildSetWindowSize(hwnd);
}
void TABLE::CreateEditControl()
{
if(hEdit || TABLE_ATTRIBUTES::AutoFill() || !TABLE_ATTRIBUTES::CanActivate())
return;
long activeRow = TABLE_ATTRIBUTES::ActiveRow();
if(activeRow<0)
return;
if((activeRow<firstRow) || (activeRow>(firstRow+numVisRows-1)))
return;
int activeCol = TABLE_ATTRIBUTES::ActiveColumn();
if(!COLUMN::CanEdit(activeCol))
return;
RUNTIMEINFO* rtime = (RUNTIMEINFO*)AObjGetRuntimeInfo(theObject);
ROW* row = rtime->GetRow();
if(!row->IsSelected(activeRow))
return;
int width = COLUMN::ColumnWidth(activeCol);
if(width==0)
return;
int height = TABLE_ATTRIBUTES::CellHeight();
if(TABLE_ATTRIBUTES::RowLines())
height++;
int cellY = tblRect.top + ((int)(activeRow - firstRow))*height;
if(TABLE_ATTRIBUTES::ShowTitles())
{
cellY += (TABLE_ATTRIBUTES::TitleHeight()+1);
if(TABLE_ATTRIBUTES::RowLines())
cellY++;
}
if(TABLE_ATTRIBUTES::RowLines())
height--;
int cellX = tblRect.left;
for(int i=0; i<activeCol; i++)
{
if((i>=TABLE_ATTRIBUTES::NumFixedColumns()) && (i<firstColumn))
continue;
if(COLUMN::ColumnWidth(i)==0)
{
if((i==(TABLE_ATTRIBUTES::NumFixedColumns()-1))
&&
(cellX!=tblRect.left))
cellX++;
continue;
}
cellX += COLUMN::ColumnWidth(i);
if(TABLE_ATTRIBUTES::ColumnLines())
cellX++;
if(i==(TABLE_ATTRIBUTES::NumFixedColumns()-1))
cellX++;
}
HDC hDC = GetDC(hTable);
HPEN hPen = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_WINDOW));
LOGBRUSH lb = {BS_SOLID, GetSysColor(COLOR_WINDOW), 0};
HPEN oldPen = (HPEN)SelectObject(hDC, hPen);
HBRUSH hBrush = CreateBrushIndirect(&lb);
HBRUSH oldBrush = (HBRUSH)SelectObject(hDC, hBrush);
int right = cellX+width;
if(right>tblRect.right)
right = tblRect.right;
Rectangle(hDC, cellX, cellY, right, cellY+height);
SelectObject(hDC, oldPen);
DeleteObject(hPen);
SelectObject(hDC, oldBrush);
DeleteObject(hBrush);
ReleaseDC(hParentWnd, hDC);
cellX += COLUMN::CellCharWidth(activeCol);
width -= 2*COLUMN::CellCharWidth(activeCol);
if((cellX+width)>tblRect.right)
width = tblRect.right - cellX;
int offset = 2*TABLE_ATTRIBUTES::CellLeading()/3 + TABLE_ATTRIBUTES::CellAscent() - COLUMN::CellAscent(activeCol);
cellY = cellY + offset;
height = TABLE_ATTRIBUTES::CellHeight() - offset;
editRow = activeRow;
editCol = activeCol;
char huge* cellPtr = row->GetCell(activeRow, activeCol, FALSE, NULL);
UINT length = (UINT)hstrlen(cellPtr) + 1;
char* cellStr = new char[length];
hmemcpy(cellStr, cellPtr, length);
hEdit = CreateWindow("EDIT", cellStr,
WS_CHILD | ES_AUTOHSCROLL,
cellX, cellY,
width, height,
hTable, (HMENU)3, G.hInstance, NULL);
delete cellStr;
// subclass the edit control
SetProp(hEdit, "loPtr", (HANDLE)LOWORD((DWORD)this));
SetProp(hEdit, "hiPtr", (HANDLE)HIWORD((DWORD)this));
SetProp(hEdit, "number", (HANDLE)AObjCheckType(COLUMN::GetObjectID(activeCol), OTYPE_NUMBER));
oldEditControlProc = (WNDPROC)GetWindowLong(hEdit, GWL_WNDPROC);
SetWindowLong(hEdit, GWL_WNDPROC, (long)EditControlProc);
ShowWindow(hEdit, SW_SHOW);
hEditFont =CreateFontIndirect(COLUMN::CellLogFont(activeCol));
SendMessage(hEdit, WM_SETFONT, (WPARAM)hEditFont, MAKELPARAM(TRUE, 0));
SetFocus(hEdit);
SendMessage(hEdit, EM_SETSEL, (WPARAM)FALSE, MAKELPARAM(0, -1));
// wipPreventThieves(ParentID, TRUE); SKJ --> need replacement
AEvtPostSignalAtMark(theObject, SIGNAL_STARTEDITING);
}
long UPSF::BitmapCore_To_UBit(
HGLOBAL& hUniv,
long& univSize,
void* natvPtr,
long natvLen)
{
BITMAPCOREHEADER* bmpCH = (BITMAPCOREHEADER*)natvPtr;
WORD bitCount = bmpCH->bcBitCount;
if(!(bitCount==1 || bitCount==4 || bitCount==8 || bitCount==24))
return AUPSF_CANTCONVERT;
long ColorTableSize;
long BitmapSize;
if(bitCount==24)
{
// 24-bit color -- no color table
ColorTableSize = 0;
}
else
ColorTableSize = pow2(bitCount);
BitmapSize = natvLen - (long)sizeof(BITMAPCOREHEADER) - ColorTableSize*sizeof(RGBTRIPLE);
univSize = BitmapSize + ColorTableSize*sizeof(RGBQUAD) + (long)sizeof(BITMAPINFOHEADER);
if(!(hUniv = GlobalReAlloc(hUniv, univSize, MEMFLAGS)))
return AUPSF_MEMORYERROR;
void* univPtr = GlobalLock(hUniv);
if(!univPtr)
return AUPSF_MEMORYERROR;
// store the bitmap info header
BITMAPINFOHEADER* bmpIH = (BITMAPINFOHEADER*)univPtr;
bmpIH->biSize = sizeof(BITMAPINFOHEADER);
bmpIH->biWidth = bmpCH->bcWidth;
bmpIH->biHeight = bmpCH->bcHeight;
bmpIH->biPlanes = bmpCH->bcPlanes;
bmpIH->biBitCount = bmpCH->bcBitCount;
bmpIH->biCompression = BI_RGB;
bmpIH->biXPelsPerMeter = 0;
bmpIH->biYPelsPerMeter = 0;
bmpIH->biSizeImage = 0;
bmpIH->biClrUsed = 0;
bmpIH->biClrImportant = 0;
// store the color table
RGBTRIPLE* rgbTriple = (RGBTRIPLE*)((BYTE*)natvPtr + sizeof(BITMAPCOREHEADER));
RGBQUAD* rgbQuad = (RGBQUAD*)((BYTE*)univPtr + sizeof(BITMAPINFOHEADER));
for(int i=0; i<ColorTableSize; i++)
{
rgbQuad[i].rgbBlue = rgbTriple[i].rgbtBlue;
rgbQuad[i].rgbGreen = rgbTriple[i].rgbtGreen;
rgbQuad[i].rgbRed = rgbTriple[i].rgbtRed;
rgbQuad[i].rgbReserved = 0;
}
// store the bitmap
void* UnivBitmapBits = (void*)((BYTE*)univPtr + (size_t)(sizeof(BITMAPINFOHEADER) + ColorTableSize*sizeof(RGBQUAD)));
void* NatvBitmapBits = (void*)((BYTE*)natvPtr + (size_t)(sizeof(BITMAPCOREHEADER) + ColorTableSize*sizeof(RGBTRIPLE)));
hmemcpy(UnivBitmapBits, NatvBitmapBits, BitmapSize);
GlobalUnlock(hUniv);
return AUPSF_NOERROR;
}
