mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3837 lines
133 KiB
3837 lines
133 KiB
/*
|
|
| Outside In for Windows
|
|
| Source File OIDRTNS.C (Database window untility routines)
|
|
|
|
|
| ²²²²² ²²²²²
|
|
| ² ² ²
|
|
| ² ² ²
|
|
| ² ² ²
|
|
| ²²²²² ²²²²²
|
|
|
|
|
| Outside In
|
|
|
|
|
*/
|
|
|
|
/*
|
|
| Creation Date: 10/14/90
|
|
| Original Programmer: Philip Boutros
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
#include <platform.h>
|
|
#include <bad.h>
|
|
|
|
//#include <math.h>
|
|
|
|
#include <sccut.h>
|
|
#include <sccch.h>
|
|
#include <sccbk.h>
|
|
#include <sccvw.h>
|
|
#include <sccd.h>
|
|
#include <sccfont.h>
|
|
|
|
#include "oid.h"
|
|
#include "oid.pro"
|
|
|
|
extern HANDLE hInst;
|
|
|
|
VOID OIDSetFontInfo(lpDataInfo,lpFontInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
LPSCCDFONTINFO lpFontInfo;
|
|
{
|
|
WORD FAR * locColPosPtr;
|
|
WORD locPos;
|
|
WORD locIndex;
|
|
LPFONTINFO locFontInfoPtr;
|
|
|
|
lpDataInfo->diFontInfo = *lpFontInfo;
|
|
|
|
if (lpDataInfo->diFlags & OIDF_SECTIONOPEN)
|
|
{
|
|
locFontInfoPtr = UTGetFontDirect(lpDataInfo->diGen.hScreenIC,lpDataInfo->diFontInfo.fiFaceName,lpDataInfo->diFontInfo.fiFaceSize,0);
|
|
lpDataInfo->diFontAvgWidth = locFontInfoPtr->wFontAvgWid;
|
|
lpDataInfo->diDefRowHeight = locFontInfoPtr->wFontHeight + 3;
|
|
lpDataInfo->diDefRowHeight += lpDataInfo->diDefRowHeight % 2;
|
|
lpDataInfo->diColHeaderHeight = lpDataInfo->diDefRowHeight;
|
|
lpDataInfo->diRowHeaderWidth = locFontInfoPtr->wFontAvgWid * 6;
|
|
|
|
locColPosPtr = (WORD FAR *) GlobalLock(lpDataInfo->diColPosBuf);
|
|
|
|
locPos = 0;
|
|
|
|
for (locIndex = 0; locIndex <= lpDataInfo->diLastColInData; locIndex++)
|
|
{
|
|
locColPosPtr[locIndex] = locPos;
|
|
locPos += OIDGetColWidth(lpDataInfo,locIndex);
|
|
}
|
|
|
|
GlobalUnlock(lpDataInfo->diColPosBuf);
|
|
|
|
InvalidateRect(lpDataInfo->diGen.hWnd,NULL,TRUE);
|
|
}
|
|
}
|
|
|
|
VOID OIDOpenSection(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
WORD locIndex;
|
|
RECT locRect;
|
|
CHSECTIONINFO locSecInfo;
|
|
PCHUNK lpChunkTable;
|
|
WORD FAR * lpColPos;
|
|
int i;
|
|
LPFONTINFO locFontInfoPtr;
|
|
|
|
UTFlagOn(lpDataInfo->diFlags,OIDF_SECTIONOPEN);
|
|
|
|
/*
|
|
| Initialize the line displayed at the top of the window to zero
|
|
*/
|
|
|
|
lpDataInfo->diCurTopRow = 0;
|
|
lpDataInfo->diCurLeftCol = 0;
|
|
lpDataInfo->diLastCaretRow = 0;
|
|
lpDataInfo->diLastCaretCol = 0;
|
|
lpDataInfo->diSelectAnchorRow = 0;
|
|
lpDataInfo->diSelectAnchorCol = 0;
|
|
lpDataInfo->diSelectEndRow = 0;
|
|
lpDataInfo->diSelectEndCol = 0;
|
|
lpDataInfo->diSelectMode = OIDSELECT_BLOCK;
|
|
|
|
/*
|
|
| Get font info for default font
|
|
*/
|
|
|
|
locFontInfoPtr = UTGetFontDirect(lpDataInfo->diGen.hScreenIC,lpDataInfo->diFontInfo.fiFaceName,lpDataInfo->diFontInfo.fiFaceSize,0);
|
|
lpDataInfo->diFontAvgWidth = locFontInfoPtr->wFontAvgWid;
|
|
lpDataInfo->diDefRowHeight = locFontInfoPtr->wFontHeight + 3;
|
|
lpDataInfo->diDefRowHeight += lpDataInfo->diDefRowHeight % 2;
|
|
lpDataInfo->diColHeaderHeight = lpDataInfo->diDefRowHeight;
|
|
lpDataInfo->diRowHeaderWidth = locFontInfoPtr->wFontAvgWid * 6;
|
|
|
|
/*
|
|
| Get section info
|
|
*/
|
|
|
|
|
|
CHGetSecInfo(lpDataInfo->diGen.hFilter,lpDataInfo->diGen.wSection,(PCHSECTIONINFO) &locSecInfo);
|
|
|
|
lpDataInfo->diChunkTable = locSecInfo.hChunkTable;
|
|
|
|
if (locSecInfo.wType != SO_FIELDS)
|
|
{
|
|
SccDebugOut("Non database section sent to database viewer");
|
|
return;
|
|
}
|
|
|
|
if (locSecInfo.Flags & CH_SECTIONFINISHED)
|
|
{
|
|
UTFlagOn(lpDataInfo->diFlags,OIDF_SIZEKNOWN);
|
|
}
|
|
|
|
lpDataInfo->diFieldInfo = CHGetSecData(lpDataInfo->diGen.hFilter,lpDataInfo->diGen.wSection);
|
|
lpDataInfo->diFirstChunk = 0;
|
|
lpDataInfo->diLastChunk = locSecInfo.IDLastChunk;
|
|
lpDataInfo->diDateBase = locSecInfo.Attr.Fields.dwDateBase;
|
|
lpDataInfo->diDateFlags = locSecInfo.Attr.Fields.wDateFlags;
|
|
|
|
lpChunkTable = (PCHUNK) GlobalLock(lpDataInfo->diChunkTable);
|
|
|
|
lpDataInfo->diLastColInData = locSecInfo.Attr.Fields.wNumCols-1;
|
|
lpDataInfo->diLastRowInData = lpChunkTable[lpDataInfo->diLastChunk].Info.Fields.dwLastRec;
|
|
|
|
GlobalUnlock(lpDataInfo->diChunkTable);
|
|
|
|
lpDataInfo->diColPosBuf = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,sizeof(WORD)*(lpDataInfo->diLastColInData+1));
|
|
lpColPos = (WORD FAR *) GlobalLock(lpDataInfo->diColPosBuf);
|
|
|
|
i=0;
|
|
|
|
for (locIndex = 0; locIndex <= lpDataInfo->diLastColInData; locIndex++)
|
|
{
|
|
lpColPos[locIndex] = i;
|
|
i += OIDGetColWidth(lpDataInfo,locIndex);
|
|
}
|
|
|
|
GlobalUnlock(lpDataInfo->diColPosBuf);
|
|
|
|
/*
|
|
| Get size of window and set the client height
|
|
*/
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locRect);
|
|
lpDataInfo->diClientHeight = locRect.bottom;
|
|
lpDataInfo->diClientWidth = locRect.right;
|
|
|
|
/*
|
|
| Zero scroll bar positions
|
|
*/
|
|
|
|
OIDUpdateVertScrollPos(lpDataInfo);
|
|
OIDUpdateHorzScrollPos(lpDataInfo);
|
|
|
|
/*
|
|
| Tell parent that Copy is always available
|
|
*/
|
|
|
|
SendMessage(GetParent(lpDataInfo->diGen.hWnd),SCCVW_SELCHANGE,TRUE,0);
|
|
}
|
|
|
|
VOID OIDDoReadAhead(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
CHSECTIONINFO locSecInfo;
|
|
PCHUNK pChunkTable;
|
|
|
|
DWORD locNewLastRow;
|
|
RECT locRect;
|
|
int locIndex;
|
|
|
|
|
|
if (!(lpDataInfo->diFlags & OIDF_SIZEKNOWN))
|
|
{
|
|
CHGetSecInfo(lpDataInfo->diGen.hFilter,lpDataInfo->diGen.wSection,&locSecInfo);
|
|
|
|
if (locSecInfo.Flags & CH_SECTIONFINISHED)
|
|
{
|
|
UTFlagOn(lpDataInfo->diFlags,OIDF_SIZEKNOWN);
|
|
}
|
|
|
|
lpDataInfo->diChunkTable = locSecInfo.hChunkTable;
|
|
lpDataInfo->diLastChunk = locSecInfo.IDLastChunk;
|
|
|
|
pChunkTable = (PCHUNK) GlobalLock(lpDataInfo->diChunkTable);
|
|
|
|
for (locIndex = lpDataInfo->diLastChunk; locIndex > 0; locIndex--)
|
|
{
|
|
if (pChunkTable[locIndex].Flags & CH_COMPLETE) break;
|
|
}
|
|
|
|
locNewLastRow = pChunkTable[locIndex].Info.Fields.dwLastRec;
|
|
|
|
if (locNewLastRow > lpDataInfo->diLastRowInData)
|
|
{
|
|
if (lpDataInfo->diLastRowInData < lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo))
|
|
{
|
|
if (lpDataInfo->diLastRowInData > lpDataInfo->diCurTopRow)
|
|
OIDMapCellToRect(lpDataInfo,0,lpDataInfo->diLastRowInData,&locRect);
|
|
else
|
|
OIDMapCellToRect(lpDataInfo,0,lpDataInfo->diCurTopRow,&locRect);
|
|
|
|
locRect.left = 0;
|
|
locRect.right = lpDataInfo->diClientWidth;
|
|
locRect.bottom = lpDataInfo->diClientHeight;
|
|
|
|
lpDataInfo->diLastRowInData = locNewLastRow;
|
|
|
|
InvalidateRect(lpDataInfo->diGen.hWnd,&locRect,TRUE);
|
|
}
|
|
|
|
lpDataInfo->diLastRowInData = locNewLastRow;
|
|
lpDataInfo->diLastColInData = locSecInfo.Attr.Fields.wNumCols-1;
|
|
}
|
|
|
|
OIDUpdateVertScrollPos(lpDataInfo);
|
|
OIDUpdateHorzScrollPos(lpDataInfo);
|
|
|
|
GlobalUnlock(lpDataInfo->diChunkTable);
|
|
}
|
|
}
|
|
|
|
VOID OIDSizeWnd(lpDataInfo,wWidth,wHeight)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wWidth;
|
|
WORD wHeight;
|
|
{
|
|
lpDataInfo->diClientHeight = wHeight;
|
|
lpDataInfo->diClientWidth = wWidth;
|
|
}
|
|
|
|
VOID OIDPaintWnd(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
DWORD locRowBegin;
|
|
DWORD locRowEnd;
|
|
WORD locColBegin;
|
|
WORD locColEnd;
|
|
|
|
DWORD locRow;
|
|
WORD locCol;
|
|
|
|
RECT locRect;
|
|
HDC locDC;
|
|
LPFONTINFO locFontInfoPtr;
|
|
|
|
locDC = BeginPaint(lpDataInfo->diGen.hWnd,&lpDataInfo->diPaint);
|
|
UTFlagOn(lpDataInfo->diErrorFlags,OIDF_RELEASEPAINT);
|
|
|
|
locRect = lpDataInfo->diPaint.rcPaint;
|
|
|
|
locFontInfoPtr = UTGetFontDirect(locDC,lpDataInfo->diFontInfo.fiFaceName,lpDataInfo->diFontInfo.fiFaceSize,0);
|
|
|
|
SelectObject(locDC,GetStockObject(NULL_BRUSH));
|
|
SelectObject(locDC,locFontInfoPtr->hFont);
|
|
|
|
SetTextColor(locDC,lpDataInfo->diFontInfo.fiTextColor);
|
|
SetBkColor(locDC,lpDataInfo->diFontInfo.fiBackColor);
|
|
|
|
/*
|
|
| Calculate the rows and columns that must be updated
|
|
*/
|
|
|
|
OIDMapXyToCell(lpDataInfo, locRect.left, locRect.top, &locColBegin, &locRowBegin);
|
|
OIDMapXyToCell(lpDataInfo, locRect.right, locRect.bottom, &locColEnd, &locRowEnd);
|
|
|
|
/*
|
|
| Adjust Row & Col Begin so Row & Col headers will not be overwritten
|
|
*/
|
|
|
|
if (locRowBegin < lpDataInfo->diCurTopRow)
|
|
locRowBegin = lpDataInfo->diCurTopRow;
|
|
|
|
if (locColBegin < lpDataInfo->diCurLeftCol)
|
|
locColBegin = lpDataInfo->diCurLeftCol;
|
|
|
|
/*
|
|
| Display blank area
|
|
*/
|
|
|
|
OIDDisplayBlank(lpDataInfo,locDC,locRowEnd,locColEnd);
|
|
|
|
/*
|
|
| Display grid
|
|
*/
|
|
|
|
OIDDisplayGrid(lpDataInfo,locDC,locRowBegin,locRowEnd,locColBegin,locColEnd);
|
|
|
|
/*
|
|
| Display Row & Col headings
|
|
*/
|
|
|
|
locFontInfoPtr = UTGetFontDirect(locDC,lpDataInfo->diFontInfo.fiFaceName,lpDataInfo->diFontInfo.fiFaceSize,OIFONT_BOLD);
|
|
SelectObject(locDC,locFontInfoPtr->hFont);
|
|
|
|
if (locRect.top <= lpDataInfo->diColHeaderHeight)
|
|
{
|
|
for (locCol = locColBegin; locCol <= locColEnd; locCol++)
|
|
{
|
|
OIDDisplayColHeader(lpDataInfo,locDC,locCol);
|
|
}
|
|
}
|
|
|
|
if (locRect.left <= lpDataInfo->diRowHeaderWidth)
|
|
{
|
|
for (locRow = locRowBegin; locRow <= locRowEnd; locRow++)
|
|
{
|
|
OIDDisplayRowHeader(lpDataInfo,locDC,locRow);
|
|
}
|
|
}
|
|
|
|
// ExcludeClipRect(locDC,0,0,lpDataInfo->diRowHeaderWidth,lpDataInfo->diClientHeight);
|
|
|
|
/*
|
|
| Display the required cells
|
|
*/
|
|
|
|
locFontInfoPtr = UTGetFontDirect(locDC,lpDataInfo->diFontInfo.fiFaceName,lpDataInfo->diFontInfo.fiFaceSize,OIFONT_NORMAL);
|
|
SelectObject(locDC,locFontInfoPtr->hFont);
|
|
|
|
OIDDisplayArea(lpDataInfo,locDC,locRowBegin,locRowEnd,locColBegin,locColEnd);
|
|
|
|
/*
|
|
| Display the selection, if we have focus
|
|
*/
|
|
|
|
/* NO, always do it
|
|
if (lpDataInfo->diGen.hWnd == GetFocus())
|
|
*/
|
|
OIDDrawSelection(lpDataInfo,locDC);
|
|
|
|
UTFlagOff(lpDataInfo->diErrorFlags,OIDF_RELEASEPAINT);
|
|
EndPaint(lpDataInfo->diGen.hWnd,&lpDataInfo->diPaint);
|
|
}
|
|
|
|
VOID OIDMapCellToRect(lpDataInfo,wCol,dwRow,pRect)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wCol;
|
|
DWORD dwRow;
|
|
RECT FAR * pRect;
|
|
{
|
|
int locY;
|
|
int locX;
|
|
|
|
WORD FAR * lpColPos;
|
|
|
|
lpColPos = (WORD FAR *) GlobalLock(lpDataInfo->diColPosBuf);
|
|
|
|
if (wCol < lpDataInfo->diCurLeftCol)
|
|
{
|
|
locX = -(int)(lpColPos[lpDataInfo->diCurLeftCol] - lpColPos[wCol]);
|
|
}
|
|
else
|
|
{
|
|
locX = lpColPos[wCol] - lpColPos[lpDataInfo->diCurLeftCol];
|
|
}
|
|
|
|
GlobalUnlock(lpDataInfo->diColPosBuf);
|
|
|
|
if (dwRow < lpDataInfo->diCurTopRow)
|
|
{
|
|
locY = -(int)(lpDataInfo->diDefRowHeight * (lpDataInfo->diCurTopRow-dwRow));
|
|
}
|
|
else
|
|
{
|
|
locY = (int)(lpDataInfo->diDefRowHeight * (dwRow - lpDataInfo->diCurTopRow));
|
|
}
|
|
|
|
locX += lpDataInfo->diRowHeaderWidth;
|
|
locY += lpDataInfo->diColHeaderHeight;
|
|
|
|
pRect->left = locX;
|
|
pRect->top = locY;
|
|
|
|
pRect->right = locX + OIDGetColWidth(lpDataInfo,wCol);
|
|
pRect->bottom = locY + lpDataInfo->diDefRowHeight;
|
|
|
|
return;
|
|
}
|
|
|
|
WORD OIDMapXyToCell(lpDataInfo,wX,wY,pCol,pRow)
|
|
LPOIDATAINFO lpDataInfo;
|
|
int wX;
|
|
int wY;
|
|
WORD FAR * pCol;
|
|
DWORD FAR * pRow;
|
|
{
|
|
DWORD locRow;
|
|
int locY;
|
|
WORD locCol;
|
|
int locX;
|
|
|
|
WORD locRet;
|
|
|
|
locRet = NULL;
|
|
|
|
if (wX < lpDataInfo->diRowHeaderWidth)
|
|
{
|
|
wX = lpDataInfo->diRowHeaderWidth;
|
|
UTFlagOn(locRet,OIDF_INROWHEADER);
|
|
}
|
|
|
|
if (wY < lpDataInfo->diColHeaderHeight)
|
|
{
|
|
wY = lpDataInfo->diColHeaderHeight;
|
|
UTFlagOn(locRet,OIDF_INCOLHEADER);
|
|
}
|
|
|
|
locRow = lpDataInfo->diCurTopRow;
|
|
locY = lpDataInfo->diColHeaderHeight;
|
|
|
|
while (locY <= wY && OIDScanForRow(lpDataInfo,locRow))
|
|
{
|
|
locY += OIDGetRowHeight(lpDataInfo,locRow);
|
|
locRow++;
|
|
}
|
|
|
|
*pRow = locRow - 1;
|
|
|
|
locCol = lpDataInfo->diCurLeftCol;
|
|
locX = lpDataInfo->diRowHeaderWidth;
|
|
|
|
while (locX <= wX && locCol <= lpDataInfo->diLastColInData)
|
|
{
|
|
locX += OIDGetColWidth(lpDataInfo,locCol);
|
|
locCol++;
|
|
}
|
|
|
|
*pCol = locCol - 1;
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
DWORD OIDGetCell(lpDataInfo,dwRow,wCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
DWORD dwRow;
|
|
WORD wCol;
|
|
{
|
|
PCHUNK lpChunkTable;
|
|
|
|
WORD locDestCell;
|
|
WORD locCellOffset;
|
|
|
|
LPSTR locChunkPtr;
|
|
LPSTR locChunkTop;
|
|
|
|
HANDLE locChunk;
|
|
WORD locChunkIndex;
|
|
|
|
DWORD locRet;
|
|
|
|
if (dwRow <= lpDataInfo->diLastRowInData && wCol <= lpDataInfo->diLastColInData)
|
|
{
|
|
lpChunkTable = (PCHUNK) GlobalLock(lpDataInfo->diChunkTable);
|
|
|
|
locChunkIndex = 0;
|
|
|
|
/*
|
|
| Run through Chunk Table until chunk with wCol & dwRow in it is found
|
|
*/
|
|
|
|
for (locChunkIndex = lpDataInfo->diFirstChunk; locChunkIndex <= lpDataInfo->diLastChunk; locChunkIndex++)
|
|
{
|
|
if (
|
|
(lpChunkTable[locChunkIndex].Flags & CH_COMPLETE) &&
|
|
dwRow >= lpChunkTable[locChunkIndex].Info.Fields.dwFirstRec &&
|
|
dwRow <= lpChunkTable[locChunkIndex].Info.Fields.dwLastRec
|
|
)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (locChunkIndex > lpDataInfo->diLastChunk)
|
|
{
|
|
/*
|
|
wsprintf(locStr,"\r\nOIGetDataChunk - Out of Range - Row %li Col %i",dwRow,wCol);
|
|
SccDebugOut(locStr);
|
|
*/
|
|
locRet = NULL;
|
|
}
|
|
else
|
|
{
|
|
locDestCell = (WORD)(dwRow - lpChunkTable[locChunkIndex].Info.Fields.dwFirstRec) * (lpDataInfo->diLastColInData+1) + wCol;
|
|
|
|
locChunk = CHGetChunk(lpDataInfo->diGen.wSection,locChunkIndex,lpDataInfo->diGen.hFilter);
|
|
|
|
locChunkPtr = locChunkTop = GlobalLock(locChunk);
|
|
locChunkPtr += SO_CHUNK_SIZE;
|
|
locChunkPtr -= sizeof(WORD) * (locDestCell + 1);
|
|
locCellOffset = *(WORD FAR *)locChunkPtr;
|
|
|
|
if (locCellOffset & 0x8000) /* Empty */
|
|
{
|
|
locRet = NULL;
|
|
}
|
|
else
|
|
{
|
|
locRet = MAKELONG(locCellOffset,locChunk);
|
|
}
|
|
|
|
GlobalUnlock(locChunk);
|
|
}
|
|
|
|
GlobalUnlock(lpDataInfo->diChunkTable);
|
|
}
|
|
else
|
|
{
|
|
locRet = NULL;
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
VOID FAR * OILockCell(dwCell)
|
|
DWORD dwCell;
|
|
{
|
|
LPSTR locChunkPtr;
|
|
|
|
if (dwCell == NULL)
|
|
{
|
|
return(NULL);
|
|
}
|
|
else
|
|
{
|
|
locChunkPtr = GlobalLock(HIWORD(dwCell));
|
|
locChunkPtr += LOWORD(dwCell);
|
|
return((VOID FAR *)locChunkPtr);
|
|
}
|
|
}
|
|
|
|
VOID OIUnlockCell(dwCell)
|
|
DWORD dwCell;
|
|
{
|
|
if (dwCell != NULL)
|
|
{
|
|
GlobalUnlock(HIWORD(dwCell));
|
|
}
|
|
}
|
|
|
|
|
|
VOID OIDDisplayColHeader(lpDataInfo,hDC,wCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
WORD wCol;
|
|
{
|
|
RECT locRect;
|
|
|
|
WORD FAR * lpColPos;
|
|
SOFIELD FAR * lpFieldInfo;
|
|
|
|
lpColPos = (WORD FAR *) GlobalLock(lpDataInfo->diColPosBuf);
|
|
|
|
if (wCol < lpDataInfo->diCurLeftCol)
|
|
{
|
|
locRect.left = -(int)(lpColPos[lpDataInfo->diCurLeftCol] - lpColPos[wCol]);
|
|
}
|
|
else
|
|
{
|
|
locRect.left = lpColPos[wCol] - lpColPos[lpDataInfo->diCurLeftCol];
|
|
}
|
|
|
|
GlobalUnlock(lpDataInfo->diColPosBuf);
|
|
|
|
locRect.left += lpDataInfo->diRowHeaderWidth;
|
|
locRect.right = locRect.left + OIDGetColWidth(lpDataInfo,wCol);
|
|
locRect.left -= 1;
|
|
locRect.top = -1;
|
|
|
|
locRect.bottom = lpDataInfo->diColHeaderHeight;
|
|
|
|
|
|
SelectObject(hDC,GetStockObject(LTGRAY_BRUSH));
|
|
SelectObject(hDC,GetStockObject(BLACK_PEN));
|
|
Rectangle(hDC,locRect.left,locRect.top,locRect.right,locRect.bottom);
|
|
SelectObject(hDC,GetStockObject(WHITE_PEN));
|
|
MoveTo(hDC,locRect.left+1,locRect.bottom-2);
|
|
LineTo(hDC,locRect.left+1,locRect.top+1);
|
|
LineTo(hDC,locRect.right-1,locRect.top+1);
|
|
|
|
SetBkMode(hDC,TRANSPARENT);
|
|
|
|
lpFieldInfo = (SOFIELD FAR *) GlobalLock(lpDataInfo->diFieldInfo);
|
|
|
|
DrawText(hDC,lpFieldInfo[wCol].szName,-1,&locRect,DT_SINGLELINE | DT_VCENTER | DT_CENTER | DT_NOPREFIX);
|
|
|
|
GlobalUnlock(lpDataInfo->diFieldInfo);
|
|
}
|
|
|
|
VOID OIDGetColHeader(lpDataInfo,wCol,lpStr)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wCol;
|
|
LPSTR lpStr;
|
|
{
|
|
SOFIELD FAR * lpFieldInfo;
|
|
|
|
lpFieldInfo = (SOFIELD FAR *) GlobalLock(lpDataInfo->diFieldInfo);
|
|
lstrcpy(lpStr,lpFieldInfo[wCol].szName);
|
|
GlobalUnlock(lpDataInfo->diFieldInfo);
|
|
}
|
|
|
|
VOID OIDDisplayRowHeader(lpDataInfo,hDC,dwRow)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRow;
|
|
{
|
|
BYTE locStr[10];
|
|
RECT locRect;
|
|
|
|
if (dwRow < lpDataInfo->diCurTopRow)
|
|
{
|
|
locRect.top = -(int)(lpDataInfo->diDefRowHeight * (lpDataInfo->diCurTopRow-dwRow));
|
|
}
|
|
else
|
|
{
|
|
locRect.top = (int)(lpDataInfo->diDefRowHeight * (WORD)(dwRow - lpDataInfo->diCurTopRow));
|
|
}
|
|
|
|
locRect.top += lpDataInfo->diColHeaderHeight;
|
|
locRect.bottom = locRect.top + lpDataInfo->diDefRowHeight;
|
|
locRect.top -= 1;
|
|
|
|
locRect.left = 0;
|
|
locRect.right = lpDataInfo->diRowHeaderWidth;
|
|
|
|
wsprintf(locStr,"%lu",dwRow+1);
|
|
|
|
SelectObject(hDC,GetStockObject(LTGRAY_BRUSH));
|
|
SelectObject(hDC,GetStockObject(BLACK_PEN));
|
|
Rectangle(hDC,locRect.left,locRect.top,locRect.right,locRect.bottom);
|
|
SelectObject(hDC,GetStockObject(WHITE_PEN));
|
|
MoveTo(hDC,locRect.left+1,locRect.bottom-2);
|
|
LineTo(hDC,locRect.left+1,locRect.top+1);
|
|
LineTo(hDC,locRect.right-1,locRect.top+1);
|
|
|
|
SetBkMode(hDC,TRANSPARENT);
|
|
|
|
DrawText(hDC,locStr,-1,&locRect,DT_SINGLELINE | DT_VCENTER | DT_CENTER | DT_NOPREFIX);
|
|
}
|
|
|
|
VOID OIDDisplayBlank(lpDataInfo,hDC,dwRowEnd,wColEnd)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRowEnd;
|
|
WORD wColEnd;
|
|
{
|
|
RECT locRect;
|
|
HBRUSH locOldBrush;
|
|
|
|
if (dwRowEnd == lpDataInfo->diLastRowInData)
|
|
{
|
|
OIDMapCellToRect(lpDataInfo,wColEnd,dwRowEnd,&locRect);
|
|
|
|
if (locRect.bottom < lpDataInfo->diClientHeight)
|
|
{
|
|
// UnrealizeObject(lpDataInfo->diGridBrush);
|
|
locOldBrush = SelectObject(hDC,GetStockObject(GRAY_BRUSH));
|
|
// SetBrushOrg(hDC,0,0);
|
|
|
|
PatBlt(hDC,0,locRect.bottom,lpDataInfo->diClientWidth,lpDataInfo->diClientHeight - locRect.bottom, PATCOPY);
|
|
|
|
SelectObject(hDC,locOldBrush);
|
|
}
|
|
}
|
|
|
|
if (wColEnd == lpDataInfo->diLastColInData)
|
|
{
|
|
OIDMapCellToRect(lpDataInfo,wColEnd,dwRowEnd,&locRect);
|
|
|
|
if (locRect.right < lpDataInfo->diClientWidth)
|
|
{
|
|
// UnrealizeObject(lpDataInfo->diGridBrush);
|
|
locOldBrush = SelectObject(hDC,GetStockObject(GRAY_BRUSH));
|
|
// locOldBrush = SelectObject(hDC,lpDataInfo->diGridBrush);
|
|
// SetBrushOrg(hDC,0,0);
|
|
|
|
PatBlt(hDC, locRect.right, 0, lpDataInfo->diClientWidth - locRect.right, lpDataInfo->diClientHeight, PATCOPY);
|
|
|
|
SelectObject(hDC,locOldBrush);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID OIDDisplayGrid(lpDataInfo,hDC,dwRowBegin,dwRowEnd,wColBegin,wColEnd)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRowBegin;
|
|
DWORD dwRowEnd;
|
|
WORD wColBegin;
|
|
WORD wColEnd;
|
|
{
|
|
DWORD locRow;
|
|
WORD locCol;
|
|
RECT locRect;
|
|
HBRUSH locOldBrush;
|
|
|
|
WORD locLeft;
|
|
WORD locTop;
|
|
WORD locWidth;
|
|
WORD locHeight;
|
|
|
|
if (!(gDbOp.wDisplay & DBOP_DISPLAY_GRIDLINES))
|
|
return;
|
|
|
|
OIDMapCellToRect(lpDataInfo,wColBegin,dwRowBegin,&locRect);
|
|
|
|
locLeft = locRect.left - (locRect.left % 2);
|
|
locTop = locRect.top - (locRect.top % 2);
|
|
|
|
OIDMapCellToRect(lpDataInfo,wColEnd,dwRowEnd,&locRect);
|
|
|
|
locWidth = locRect.right - locLeft;
|
|
locHeight = locRect.bottom - locTop;
|
|
|
|
UnrealizeObject(lpDataInfo->diGridBrush);
|
|
locOldBrush = SelectObject(hDC,lpDataInfo->diGridBrush);
|
|
SetBrushOrg(hDC,0,0);
|
|
|
|
for (locRow = dwRowBegin; locRow <= dwRowEnd; locRow++)
|
|
{
|
|
OIDMapCellToRect(lpDataInfo,wColBegin,locRow,&locRect);
|
|
PatBlt(hDC,locLeft,locRect.bottom-1,locWidth,1,PATCOPY);
|
|
}
|
|
|
|
locCol = 0;
|
|
/*
|
|
for (locCol = wColBegin; locCol <= wColEnd; locCol++)
|
|
{
|
|
OIDMapCellToRect(lpDataInfo,locCol,dwRowBegin,&locRect);
|
|
PatBlt(hDC,locRect.right-1,locTop,1,locHeight,PATCOPY);
|
|
}
|
|
*/
|
|
SelectObject(hDC,locOldBrush);
|
|
}
|
|
|
|
VOID OIDDisplayArea(lpDataInfo,hDC,dwRowBegin,dwRowEnd,wColBegin,wColEnd)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRowBegin;
|
|
DWORD dwRowEnd;
|
|
WORD wColBegin;
|
|
WORD wColEnd;
|
|
{
|
|
DWORD locRow;
|
|
WORD locCol;
|
|
|
|
DWORD locCell;
|
|
|
|
for (locRow = dwRowBegin; locRow <= dwRowEnd; locRow++)
|
|
{
|
|
for (locCol = wColBegin; locCol <= wColEnd; locCol++)
|
|
{
|
|
locCell = OIDGetCell(lpDataInfo,locRow,locCol);
|
|
|
|
if (locCell != NULL)
|
|
{
|
|
OIDDisplayCell(lpDataInfo,hDC,locRow,locCol,locCell);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID OIDDisplayCell(lpDataInfo,hDC,dwRow,wCol,dwCell)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRow;
|
|
WORD wCol;
|
|
DWORD dwCell;
|
|
{
|
|
RECT locRect;
|
|
VOID FAR * locFieldData;
|
|
SOFIELD FAR * locFieldInfo;
|
|
char locStr[80];
|
|
int locX;
|
|
int locY;
|
|
WORD locTextLen;
|
|
|
|
LPSTR locOutStr;
|
|
WORD locOutCount;
|
|
WORD locOutAttrib;
|
|
WORD locOutAlign;
|
|
WORD locOutFont;
|
|
|
|
LPFONTINFO locFontInfoPtr;
|
|
|
|
OIDMapCellToRect(lpDataInfo,wCol,dwRow,&locRect);
|
|
|
|
locFieldData = OILockCell(dwCell);
|
|
locFieldInfo = (SOFIELD FAR *) GlobalLock(lpDataInfo->diFieldInfo);
|
|
locFieldInfo = &locFieldInfo[wCol];
|
|
|
|
if (locFieldInfo->wStorage == SO_FIELDTEXTFIX)
|
|
{
|
|
locOutStr = locFieldData;
|
|
locOutCount = 0;
|
|
while (locOutStr[locOutCount] != 0x00 && locOutCount < locFieldInfo->wPrecision)
|
|
locOutCount++;
|
|
locOutAlign = locFieldInfo->wAlignment;
|
|
locOutAttrib = 0;
|
|
}
|
|
else if (locFieldInfo->wStorage == SO_FIELDTEXTVAR)
|
|
{
|
|
locOutStr = (BYTE FAR *)locFieldData + sizeof(WORD);
|
|
locOutCount = *(WORD FAR *)locFieldData;
|
|
locOutAlign = locFieldInfo->wAlignment;
|
|
locOutAttrib = 0;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
| Format number or date
|
|
*/
|
|
|
|
OIDFormatDataCell(lpDataInfo,locStr,locFieldInfo,locFieldData);
|
|
|
|
/*
|
|
| Setup output string pointer and length
|
|
*/
|
|
|
|
locOutStr = locStr;
|
|
locOutCount = lstrlen(locStr);
|
|
locOutAlign = locFieldInfo->wAlignment;
|
|
locOutAttrib = 0;
|
|
}
|
|
|
|
if (locOutCount)
|
|
{
|
|
locOutFont = OIFONT_NORMAL;
|
|
|
|
if (locOutAttrib & SO_CELLBOLD)
|
|
UTFlagOn(locOutFont,OIFONT_BOLD);
|
|
|
|
if (locOutAttrib & SO_CELLITALIC)
|
|
UTFlagOn(locOutFont,OIFONT_ITALIC);
|
|
|
|
if (locOutAttrib & SO_UNDERLINE)
|
|
UTFlagOn(locOutFont,OIFONT_UNDERLINE);
|
|
|
|
locFontInfoPtr = UTGetFontDirect(hDC,lpDataInfo->diFontInfo.fiFaceName,lpDataInfo->diFontInfo.fiFaceSize,locOutFont);
|
|
SelectObject(hDC,locFontInfoPtr->hFont);
|
|
|
|
SetBkMode(hDC,TRANSPARENT);
|
|
|
|
locTextLen = LOWORD(GetTextExtent(hDC,locOutStr,locOutCount));
|
|
|
|
locRect.bottom--;
|
|
|
|
switch(locOutAlign)
|
|
{
|
|
/*
|
|
case SO_CELLFILL:
|
|
break;
|
|
case SO_CELLLEFT:
|
|
locX = locRect.left + 3;
|
|
locY = locRect.top + 1;
|
|
ExtTextOut(hDC,locX,locY,ETO_CLIPPED | ETO_OPAQUE,&locRect,locOutStr,locOutCount,NULL);
|
|
break;
|
|
case SO_CELLRIGHT:
|
|
locX = locRect.right - 3 - locTextLen;
|
|
locY = locRect.top + 1;
|
|
ExtTextOut(hDC,locX,locY,ETO_CLIPPED | ETO_OPAQUE,&locRect,locOutStr,locOutCount,NULL);
|
|
break;
|
|
case SO_CELLCENTER:
|
|
locX = locRect.left + (locRect.right - locRect.left)/2 - locTextLen/2;
|
|
locY = locRect.top + 1;
|
|
ExtTextOut(hDC,locX,locY,ETO_CLIPPED | ETO_OPAQUE,&locRect,locOutStr,locOutCount,NULL);
|
|
break;
|
|
*/
|
|
|
|
case SO_CELLFILL:
|
|
break;
|
|
case SO_CELLLEFT:
|
|
locX = locRect.left + 3;
|
|
locRect.right = locX + locTextLen;
|
|
locY = locRect.top + 1;
|
|
if (locRect.left < lpDataInfo->diRowHeaderWidth) locRect.left = lpDataInfo->diRowHeaderWidth;
|
|
if (locRect.right > locRect.left)
|
|
ExtTextOut(hDC,locX,locY,ETO_CLIPPED | ETO_OPAQUE,&locRect,locOutStr,locOutCount,NULL);
|
|
break;
|
|
case SO_CELLRIGHT:
|
|
locX = locRect.right - 3 - locTextLen;
|
|
locRect.left = locX;
|
|
locRect.right--;
|
|
locY = locRect.top + 1;
|
|
if (locRect.left < lpDataInfo->diRowHeaderWidth) locRect.left = lpDataInfo->diRowHeaderWidth;
|
|
if (locRect.right > locRect.left)
|
|
ExtTextOut(hDC,locX,locY,ETO_CLIPPED | ETO_OPAQUE,&locRect,locOutStr,locOutCount,NULL);
|
|
break;
|
|
case SO_CELLCENTER:
|
|
locX = locRect.left + (locRect.right - locRect.left)/2 - locTextLen/2;
|
|
locRect.right = locRect.left + (locRect.right - locRect.left)/2 + locTextLen/2 + 1;
|
|
locRect.left = locX - 1;
|
|
locY = locRect.top + 1;
|
|
if (locRect.left < lpDataInfo->diRowHeaderWidth) locRect.left = lpDataInfo->diRowHeaderWidth;
|
|
if (locRect.right > locRect.left)
|
|
ExtTextOut(hDC,locX,locY,ETO_CLIPPED | ETO_OPAQUE,&locRect,locOutStr,locOutCount,NULL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
GlobalUnlock(lpDataInfo->diFieldInfo);
|
|
OIUnlockCell(dwCell);
|
|
}
|
|
|
|
extern short DecExponent;
|
|
extern unsigned char DecSign;
|
|
extern unsigned char DecDigits[31];
|
|
|
|
WORD IEEE4ToText(VOID FAR *,VOID FAR *);
|
|
WORD IEEE8ToText(VOID FAR *,VOID FAR *);
|
|
WORD IEEE10ToText(VOID FAR *,VOID FAR *);
|
|
VOID INT32SToText(long,VOID FAR *);
|
|
VOID INT32UToText(unsigned long,VOID FAR *);
|
|
VOID FormatDecAsFloat(VOID FAR *,WORD,WORD);
|
|
VOID FormatDecAsExp(VOID FAR *,WORD,WORD);
|
|
|
|
#define IEEE_ZERO 1
|
|
#define IEEE_NAN 2
|
|
#define IEEE_INF 3
|
|
#define IEEE_DENORM 4
|
|
|
|
VOID OIDFormatDataCell(lpDataInfo,lpResultStr,lpFieldInfo,lpFieldData)
|
|
LPOIDATAINFO lpDataInfo;
|
|
LPSTR lpResultStr;
|
|
SOFIELD FAR * lpFieldInfo;
|
|
VOID FAR * lpFieldData;
|
|
{
|
|
char locStr[40];
|
|
|
|
double locMult;
|
|
BOOL locHaveMult;
|
|
|
|
double locDouble;
|
|
|
|
DWORD locMultFactor;
|
|
|
|
BOOL locIsNum;
|
|
BOOL locIsTrue;
|
|
BOOL locIsExp;
|
|
|
|
WORD locIndexA;
|
|
WORD locIndexB;
|
|
WORD locDecPos;
|
|
WORD locToTextRet;
|
|
WORD locGenPrecision;
|
|
|
|
locGenPrecision = 2;
|
|
|
|
if (lpFieldInfo->wStorage == SO_CELLEMPTY)
|
|
{
|
|
lpResultStr[0] = 0x00;
|
|
return;
|
|
}
|
|
|
|
if (lpFieldInfo->wStorage == SO_CELLERROR)
|
|
{
|
|
lstrcpy(lpResultStr,"[Error]");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
| Set multiplication factor
|
|
*/
|
|
|
|
locHaveMult = FALSE;
|
|
|
|
locMultFactor = lpFieldInfo->dwSubDisplay & SO_CELLMULT_MASK;
|
|
|
|
switch (locMultFactor)
|
|
{
|
|
case SO_CELLMULT_01:
|
|
locHaveMult = TRUE;
|
|
locMult = 0.01;
|
|
locGenPrecision = 2;
|
|
break;
|
|
case SO_CELLMULT_5000:
|
|
locHaveMult = TRUE;
|
|
locMult = 5000;
|
|
locGenPrecision = 0;
|
|
break;
|
|
case SO_CELLMULT_500:
|
|
locHaveMult = TRUE;
|
|
locMult = 500;
|
|
locGenPrecision = 0;
|
|
break;
|
|
case SO_CELLMULT_05:
|
|
locHaveMult = TRUE;
|
|
locMult = 0.05;
|
|
locGenPrecision = 2;
|
|
break;
|
|
case SO_CELLMULT_005:
|
|
locHaveMult = TRUE;
|
|
locMult = 0.005;
|
|
locGenPrecision = 3;
|
|
break;
|
|
case SO_CELLMULT_0005:
|
|
locHaveMult = TRUE;
|
|
locMult = 0.0005;
|
|
locGenPrecision = 4;
|
|
break;
|
|
case SO_CELLMULT_00005:
|
|
locHaveMult = TRUE;
|
|
locMult = 0.00005;
|
|
locGenPrecision = 5;
|
|
break;
|
|
case SO_CELLMULT_0625:
|
|
locHaveMult = TRUE;
|
|
locMult = 0.0625;
|
|
locGenPrecision = 4;
|
|
break;
|
|
case SO_CELLMULT_015625:
|
|
locHaveMult = TRUE;
|
|
locMult = 0.015625;
|
|
locGenPrecision = 6;
|
|
break;
|
|
case SO_CELLMULT_0001:
|
|
locHaveMult = TRUE;
|
|
locMult = 0.0001;
|
|
locGenPrecision = 4;
|
|
break;
|
|
case SO_CELLMULT_1:
|
|
default:
|
|
locMult = 1;
|
|
locGenPrecision = 0;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
| Set display format
|
|
*/
|
|
|
|
switch (lpFieldInfo->wDisplay)
|
|
{
|
|
case SO_CELLNUMBER:
|
|
locIsNum = TRUE;
|
|
/*
|
|
if ((lpFieldInfo->wStorage == SO_CELLINT32S || lpFieldInfo->wStorage == SO_CELLINT32U) && locMult == 1)
|
|
lpFieldInfo->wPrecision = 0;
|
|
*/
|
|
break;
|
|
case SO_CELLEXPONENT:
|
|
locIsNum = TRUE;
|
|
break;
|
|
case SO_CELLPERCENT:
|
|
locHaveMult = TRUE;
|
|
locMult *= 100;
|
|
locIsNum = TRUE;
|
|
break;
|
|
case SO_CELLDECIMAL:
|
|
case SO_CELLDOLLARS:
|
|
locIsNum = TRUE;
|
|
break;
|
|
case SO_CELLDATETIME:
|
|
case SO_CELLDATE:
|
|
case SO_CELLTIME:
|
|
OIDFormatDateTime(lpDataInfo,lpResultStr,lpFieldInfo,lpFieldData,locMult);
|
|
locIsNum = FALSE;
|
|
break;
|
|
|
|
case SO_CELLBOOL:
|
|
|
|
switch(lpFieldInfo->wStorage)
|
|
{
|
|
case SO_CELLINT32S:
|
|
locIsTrue = (BOOL)*(signed long FAR *)lpFieldData;
|
|
break;
|
|
case SO_CELLINT32U:
|
|
locIsTrue = (BOOL)*(unsigned long FAR *)lpFieldData;
|
|
break;
|
|
case SO_CELLIEEE4I:
|
|
locIsTrue = (BOOL)*(float FAR *)lpFieldData;
|
|
break;
|
|
case SO_CELLIEEE8I:
|
|
locIsTrue = (BOOL)*(double FAR *)lpFieldData;
|
|
break;
|
|
case SO_CELLIEEE10I:
|
|
locIsTrue = (BOOL)*(long double FAR *)lpFieldData;
|
|
break;
|
|
case SO_CELLBCD8I:
|
|
locIsTrue = (BOOL)OIConvertBCDToDouble((BYTE FAR *) lpFieldData);
|
|
break;
|
|
case SO_CELLIEEE10M:
|
|
case SO_CELLIEEE8M:
|
|
case SO_CELLIEEE4M:
|
|
case SO_CELLEMPTY:
|
|
case SO_CELLERROR:
|
|
lstrcpy(lpResultStr,"BoolSpam");
|
|
break;
|
|
}
|
|
|
|
lstrcpy(lpResultStr,locIsTrue ? "True" : "False");
|
|
locIsNum = FALSE;
|
|
break;
|
|
}
|
|
|
|
/*
|
|
| if cell is a number, format it
|
|
*/
|
|
|
|
if (locIsNum)
|
|
{
|
|
locToTextRet = 0;
|
|
|
|
switch(lpFieldInfo->wStorage)
|
|
{
|
|
case SO_CELLINT32S:
|
|
|
|
INT32SToText(*(signed long FAR *)lpFieldData,locHaveMult ? (void far *) &locMult : (void far *) NULL);
|
|
break;
|
|
|
|
case SO_CELLINT32U:
|
|
|
|
INT32UToText(*(unsigned long FAR *)lpFieldData,locHaveMult ? (void far *) &locMult : (void far *) NULL);
|
|
break;
|
|
|
|
case SO_CELLIEEE4I:
|
|
|
|
locToTextRet = IEEE4ToText((float FAR *)lpFieldData,locHaveMult ? (void far *) &locMult : (void far *) NULL);
|
|
locGenPrecision = 9;
|
|
break;
|
|
|
|
case SO_CELLIEEE8I:
|
|
|
|
locToTextRet = IEEE8ToText((double FAR *)lpFieldData,locHaveMult ? (void far *) &locMult : (void far *) NULL);
|
|
locGenPrecision = 14;
|
|
break;
|
|
|
|
case SO_CELLIEEE10I:
|
|
|
|
locToTextRet = IEEE10ToText((long double FAR *)lpFieldData,locHaveMult ? (void far *) &locMult : (void far *) NULL);
|
|
locGenPrecision = 14;
|
|
break;
|
|
|
|
case SO_CELLBCD8I:
|
|
|
|
locDouble = OIConvertBCDToDouble((BYTE FAR *) lpFieldData);
|
|
locToTextRet = IEEE8ToText(&locDouble,locHaveMult ? (void far *) &locMult : (void far *) NULL);
|
|
locGenPrecision = 14;
|
|
break;
|
|
|
|
case SO_CELLIEEE10M:
|
|
case SO_CELLIEEE8M:
|
|
case SO_CELLIEEE4M:
|
|
case SO_CELLEMPTY:
|
|
case SO_CELLERROR:
|
|
locDouble = -666;
|
|
locToTextRet = IEEE8ToText(&locDouble,NULL);
|
|
break;
|
|
}
|
|
|
|
if (locToTextRet)
|
|
{
|
|
switch (locToTextRet)
|
|
{
|
|
case IEEE_ZERO:
|
|
lstrcpy(lpResultStr,"0");
|
|
break;
|
|
case IEEE_NAN:
|
|
lstrcpy(lpResultStr,"IEEE NaN");
|
|
break;
|
|
case IEEE_INF:
|
|
lstrcpy(lpResultStr,"IEEE Infinity");
|
|
break;
|
|
case IEEE_DENORM:
|
|
lstrcpy(lpResultStr,"IEEE Denorm");
|
|
break;
|
|
default:
|
|
lstrcpy(lpResultStr,"IEEE Bad");
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
locIndexB = 0;
|
|
|
|
if (DecSign == '-')
|
|
{
|
|
if (lpFieldInfo->dwSubDisplay & SO_CELLNEG_PAREN || lpFieldInfo->dwSubDisplay & SO_CELLNEG_PARENRED)
|
|
{
|
|
lpResultStr[locIndexB++] = '(';
|
|
}
|
|
else
|
|
{
|
|
lpResultStr[locIndexB++] = '-';
|
|
}
|
|
}
|
|
|
|
if (lpFieldInfo->wDisplay == SO_CELLDOLLARS)
|
|
{
|
|
lpResultStr[locIndexB++] = '$';
|
|
}
|
|
|
|
|
|
switch (lpFieldInfo->wDisplay)
|
|
{
|
|
case SO_CELLNUMBER:
|
|
if ((DecExponent > 10 || DecExponent < -5) && DecExponent > -100)
|
|
locIsExp = TRUE;
|
|
else
|
|
locIsExp = FALSE;
|
|
break;
|
|
case SO_CELLEXPONENT:
|
|
locIsExp = TRUE;
|
|
break;
|
|
default:
|
|
locIsExp = FALSE;
|
|
break;
|
|
}
|
|
|
|
if (lpFieldInfo->wDisplay == SO_CELLNUMBER)
|
|
{
|
|
if (locIsExp)
|
|
{
|
|
lpFieldInfo->wPrecision = 2;
|
|
}
|
|
else
|
|
{
|
|
if (DecExponent > (short)locGenPrecision)
|
|
lpFieldInfo->wPrecision = 0;
|
|
else
|
|
lpFieldInfo->wPrecision = (short)locGenPrecision - DecExponent;
|
|
}
|
|
}
|
|
|
|
if (locIsExp)
|
|
{
|
|
FormatDecAsExp(locStr,39,lpFieldInfo->wPrecision);
|
|
}
|
|
else
|
|
{
|
|
FormatDecAsFloat(locStr,39,lpFieldInfo->wPrecision);
|
|
|
|
if (lpFieldInfo->wDisplay == SO_CELLNUMBER && lpFieldInfo->wPrecision > 0)
|
|
{
|
|
LPSTR locStrPtr;
|
|
|
|
locStrPtr = locStr;
|
|
while (*locStrPtr) locStrPtr++;
|
|
|
|
if (locStrPtr != (LPSTR)locStr)
|
|
{
|
|
locStrPtr--;
|
|
while (*locStrPtr == '0')
|
|
{
|
|
*locStrPtr = 0;
|
|
locStrPtr--;
|
|
}
|
|
if (*locStrPtr == '.')
|
|
*locStrPtr = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
locIndexA = 0;
|
|
|
|
if (lpFieldInfo->dwSubDisplay & SO_CELL1000SEP_COMMA)
|
|
{
|
|
locDecPos = locIndexA;
|
|
|
|
while (locStr[locDecPos] >= '0' && locStr[locDecPos] <= '9')
|
|
locDecPos++;
|
|
|
|
while (locStr[locIndexA] != 0x00)
|
|
{
|
|
lpResultStr[locIndexB++] = locStr[locIndexA++];
|
|
|
|
if (locIndexA < locDecPos && (locDecPos-locIndexA) % 3 == 0)
|
|
lpResultStr[locIndexB++] = ',';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while ((lpResultStr[locIndexB++] = locStr[locIndexA++]) != 0x00);
|
|
locIndexB--;
|
|
}
|
|
|
|
|
|
if (lpFieldInfo->wDisplay == SO_CELLPERCENT)
|
|
{
|
|
lpResultStr[locIndexB++] = '%';
|
|
}
|
|
|
|
if (DecSign == '-')
|
|
{
|
|
if (lpFieldInfo->dwSubDisplay & SO_CELLNEG_PAREN || lpFieldInfo->dwSubDisplay & SO_CELLNEG_PARENRED)
|
|
{
|
|
lpResultStr[locIndexB++] = ')';
|
|
}
|
|
}
|
|
|
|
lpResultStr[locIndexB] = 0x00;
|
|
}
|
|
}
|
|
|
|
|
|
VOID OIDFormatDateTime(lpDataInfo,lpResultStr,lpFieldInfo,lpFieldData,fMult)
|
|
LPOIDATAINFO lpDataInfo;
|
|
LPSTR lpResultStr;
|
|
SOFIELD FAR * lpFieldInfo;
|
|
VOID FAR * lpFieldData;
|
|
double fMult;
|
|
{
|
|
double locJulian;
|
|
|
|
int locYear;
|
|
int locMonth;
|
|
int locDay;
|
|
int locDow;
|
|
int locHour;
|
|
int locMinute;
|
|
int locSecond;
|
|
|
|
char locDateSep[2];
|
|
char locDateDay[3];
|
|
char locDateMonth[10];
|
|
char locDateYear[5];
|
|
char locDateDow[10];
|
|
char locDateTime[10];
|
|
|
|
WORD locMonthIndex;
|
|
WORD locDayIndex;
|
|
WORD locYearIndex;
|
|
WORD locTimeIndex;
|
|
WORD locDowIndex;
|
|
|
|
char locDatePart[6][20];
|
|
WORD locIndex;
|
|
|
|
BYTE locStr[80];
|
|
|
|
|
|
static WORD locMonthsDays[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
|
|
static char locMonthsAbbrev[12][4] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
|
|
static char locMonthsFull[12][10] = {"January","February","March","April","May","June","July","August","September","October","November","December"};
|
|
static char locDowAbbrev[7][4] = {"Sun","Mon","Tue","Wed","Thr","Fri","Sat"};
|
|
static char locDowFull[7][10] = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
|
|
|
|
switch(lpFieldInfo->wStorage)
|
|
{
|
|
case SO_CELLINT32S:
|
|
locJulian = (double)(*(signed long far *)lpFieldData * fMult);
|
|
break;
|
|
case SO_CELLINT32U:
|
|
locJulian = (double)(*(unsigned long far *)lpFieldData * fMult);
|
|
break;
|
|
case SO_CELLIEEE4I:
|
|
locJulian = (double)(*(float far *)lpFieldData * fMult);
|
|
break;
|
|
case SO_CELLIEEE8I:
|
|
locJulian = (double)(*(double far *)lpFieldData * fMult);
|
|
break;
|
|
case SO_CELLIEEE10I:
|
|
locJulian = (double)(*(long double far *)lpFieldData * fMult);
|
|
break;
|
|
case SO_CELLBCD8I:
|
|
locJulian = OIConvertBCDToDouble((BYTE FAR *)lpFieldData);
|
|
break;
|
|
case SO_CELLIEEE10M:
|
|
case SO_CELLIEEE8M:
|
|
case SO_CELLIEEE4M:
|
|
case SO_CELLEMPTY:
|
|
case SO_CELLERROR:
|
|
locJulian = 0;
|
|
lstrcpy(lpResultStr,"DateSpam");
|
|
break;
|
|
}
|
|
|
|
|
|
switch(lpFieldInfo->wDisplay)
|
|
{
|
|
case SO_CELLDATETIME:
|
|
locJulian += lpDataInfo->diDateBase;
|
|
OIConvertJulianToDate((DWORD)locJulian,&locDay,&locMonth,&locYear,&locDow,lpDataInfo->diDateFlags);
|
|
OIConvertSecondsToTime(OIConvertJulianToSeconds(locJulian),&locHour,&locMinute,&locSecond);
|
|
break;
|
|
case SO_CELLDATE:
|
|
locJulian += lpDataInfo->diDateBase;
|
|
OIConvertJulianToDate((DWORD)locJulian,&locDay,&locMonth,&locYear,&locDow,lpDataInfo->diDateFlags);
|
|
break;
|
|
case SO_CELLTIME:
|
|
if (lpFieldInfo->wStorage == SO_CELLINT32S || lpFieldInfo->wStorage == SO_CELLINT32U)
|
|
OIConvertSecondsToTime((DWORD)locJulian,&locHour,&locMinute,&locSecond);
|
|
else
|
|
OIConvertSecondsToTime(OIConvertJulianToSeconds(locJulian),&locHour,&locMinute,&locSecond);
|
|
break;
|
|
}
|
|
|
|
#define TIMEMASK (SO_HHMMBIT | SO_HHMMSSBIT | SO_AMPMBIT | SO_HMSBIT)
|
|
|
|
if ((lpFieldInfo->dwSubDisplay & TIMEMASK) == SO_CELLTIME_HHMMAM)
|
|
wsprintf(locStr,"%i:%.2i %s", ((locHour+11) % 12)+1, locMinute, (LPSTR)(locHour >= 12 ? "pm" : "am"));
|
|
else if ((lpFieldInfo->dwSubDisplay & TIMEMASK) == SO_CELLTIME_HHMM24)
|
|
wsprintf(locStr,"%i:%.2i",locHour,locMinute);
|
|
else if ((lpFieldInfo->dwSubDisplay & TIMEMASK) == SO_CELLTIME_HHMMSSAM)
|
|
wsprintf(locStr,"%i:%2.2i:%2.2i %s",((locHour+11) % 12)+1, locMinute,locSecond, (LPSTR)(locHour >= 12 ? "pm" : "am"));
|
|
else if ((lpFieldInfo->dwSubDisplay & TIMEMASK) == SO_CELLTIME_HHMMSS24)
|
|
wsprintf(locStr,"%i:%2.2i:%2.2i",locHour,locMinute,locSecond);
|
|
else if ((lpFieldInfo->dwSubDisplay & TIMEMASK) == SO_CELLTIME_HHMMHMS)
|
|
wsprintf(locStr,"%ih%.2im",locHour,locMinute);
|
|
else if ((lpFieldInfo->dwSubDisplay & TIMEMASK) == SO_CELLTIME_HHMMSSHMS)
|
|
wsprintf(locStr,"%ih%2.2im%2.2is",locHour,locMinute,locSecond);
|
|
else
|
|
locStr[0] = 0x00;
|
|
|
|
lstrcpy(locDateTime,locStr);
|
|
|
|
if (lpFieldInfo->dwSubDisplay & SO_CELLDATESEP_SLASH)
|
|
lstrcpy(locDateSep,"/");
|
|
else if (lpFieldInfo->dwSubDisplay & SO_CELLDATESEP_MINUS)
|
|
lstrcpy(locDateSep,"-");
|
|
else if (lpFieldInfo->dwSubDisplay & SO_CELLDATESEP_PERIOD)
|
|
lstrcpy(locDateSep,".");
|
|
else if (lpFieldInfo->dwSubDisplay & SO_CELLDATESEP_SPACE)
|
|
lstrcpy(locDateSep," ");
|
|
else
|
|
locDateSep[0] = 0x00;
|
|
|
|
if (lpFieldInfo->dwSubDisplay & SO_CELLDAY_NUMBER)
|
|
wsprintf(locStr,"%i",locDay);
|
|
else
|
|
locStr[0] = 0x00;
|
|
|
|
lstrcpy(locDateDay,locStr);
|
|
|
|
if (lpFieldInfo->dwSubDisplay & SO_CELLMONTH_FULL)
|
|
lstrcpy(locStr,locMonthsFull[locMonth-1]);
|
|
else if (lpFieldInfo->dwSubDisplay & SO_CELLMONTH_ABBREV)
|
|
lstrcpy(locStr,locMonthsAbbrev[locMonth-1]);
|
|
else if (lpFieldInfo->dwSubDisplay & SO_CELLMONTH_NUMBER)
|
|
wsprintf(locStr,"%2i",locMonth);
|
|
else
|
|
locStr[0] = 0x00;
|
|
|
|
lstrcpy(locDateMonth,locStr);
|
|
|
|
if (lpFieldInfo->dwSubDisplay & SO_CELLYEAR_FULL || locYear < 1900 || locYear > 1999)
|
|
wsprintf(locStr,"%4.4i",locYear);
|
|
else if (lpFieldInfo->dwSubDisplay & SO_CELLYEAR_ABBREV)
|
|
wsprintf(locStr,"%2.2i",locYear % 100);
|
|
else
|
|
locStr[0] = 0x00;
|
|
|
|
lstrcpy(locDateYear,locStr);
|
|
|
|
|
|
if (lpFieldInfo->dwSubDisplay & SO_CELLDAYOFWEEK_FULL)
|
|
lstrcpy(locDateDow,locDowFull[locDow]);
|
|
else if (lpFieldInfo->dwSubDisplay & SO_CELLDAYOFWEEK_ABBREV)
|
|
lstrcpy(locDateDow,locDowAbbrev[locDow]);
|
|
else
|
|
locDateDow[0] = 0x00;
|
|
|
|
lpResultStr[0] = 0x00;
|
|
locDatePart[1][0] = 0x00;
|
|
locDatePart[2][0] = 0x00;
|
|
locDatePart[3][0] = 0x00;
|
|
locDatePart[4][0] = 0x00;
|
|
locDatePart[5][0] = 0x00;
|
|
|
|
locIndex = locMonthIndex = ((lpFieldInfo->wPrecision & SO_CELLMONTH_MASK) >> SO_CELLMONTH_SHIFT);
|
|
if (locIndex != 0)
|
|
lstrcpy(locDatePart[locIndex],locDateMonth);
|
|
|
|
locIndex = locDayIndex = ((lpFieldInfo->wPrecision & SO_CELLDAY_MASK) >> SO_CELLDAY_SHIFT);
|
|
if (locIndex != 0)
|
|
lstrcpy(locDatePart[locIndex],locDateDay);
|
|
|
|
locIndex = locYearIndex = ((lpFieldInfo->wPrecision & SO_CELLYEAR_MASK) >> SO_CELLYEAR_SHIFT);
|
|
if (locIndex != 0)
|
|
lstrcpy(locDatePart[locIndex],locDateYear);
|
|
|
|
locIndex = locTimeIndex = ((lpFieldInfo->wPrecision & SO_CELLTIME_MASK) >> SO_CELLTIME_SHIFT);
|
|
if (locIndex != 0)
|
|
lstrcpy(locDatePart[locIndex],locDateTime);
|
|
|
|
locIndex = locDowIndex = ((lpFieldInfo->wPrecision & SO_CELLDAYOFWEEK_MASK) >> SO_CELLDAYOFWEEK_SHIFT);
|
|
if (locIndex != 0)
|
|
lstrcpy(locDatePart[locIndex],locDateDow);
|
|
|
|
for (locIndex = 1; locIndex < 6; locIndex++)
|
|
{
|
|
if (locDatePart[locIndex][0] != 0x00)
|
|
{
|
|
lstrcat(lpResultStr,locDatePart[locIndex]);
|
|
|
|
if ((locIndex == locDayIndex || locIndex == locMonthIndex || locIndex == locYearIndex)
|
|
&& (locIndex+1 == locDayIndex || locIndex+1 == locMonthIndex || locIndex+1 == locYearIndex))
|
|
lstrcat(lpResultStr,locDateSep);
|
|
else
|
|
lstrcat(lpResultStr," ");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
|
|
|
|
|
|
|
|
|
| Scrolling Routines
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
VOID OIDPosVertical(lpDataInfo,wPos)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wPos;
|
|
{
|
|
lpDataInfo->diCurTopRow = (lpDataInfo->diLastRowInData * wPos) / 0x1000;
|
|
InvalidateRect(lpDataInfo->diGen.hWnd,NULL,TRUE);
|
|
OIDUpdateVertScrollPos(lpDataInfo);
|
|
}
|
|
|
|
VOID OIDPosHorizontal(lpDataInfo,wPos)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wPos;
|
|
{
|
|
lpDataInfo->diCurLeftCol = (WORD)(((DWORD) lpDataInfo->diLastColInData * (DWORD) wPos) / 0x1000);
|
|
InvalidateRect(lpDataInfo->diGen.hWnd,NULL,TRUE);
|
|
OIDUpdateHorzScrollPos(lpDataInfo);
|
|
}
|
|
|
|
VOID OIDScrollLeft(lpDataInfo,wColsToScroll)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wColsToScroll;
|
|
{
|
|
WORD locIndex;
|
|
WORD locScrollSize;
|
|
RECT locRect;
|
|
|
|
if (wColsToScroll > lpDataInfo->diCurLeftCol)
|
|
wColsToScroll = lpDataInfo->diCurLeftCol;
|
|
|
|
if (wColsToScroll > 0)
|
|
{
|
|
locScrollSize = 0;
|
|
|
|
for (locIndex = 0; locIndex < wColsToScroll; locIndex++)
|
|
{
|
|
locScrollSize +=
|
|
OIDGetColWidth(lpDataInfo,lpDataInfo->diCurLeftCol-locIndex-1);
|
|
}
|
|
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locRect);
|
|
locRect.left += lpDataInfo->diRowHeaderWidth;
|
|
ScrollWindow(lpDataInfo->diGen.hWnd, locScrollSize, 0, &locRect, &locRect);
|
|
lpDataInfo->diCurLeftCol -= wColsToScroll;
|
|
|
|
OIDUpdateHorzScrollPos(lpDataInfo);
|
|
}
|
|
}
|
|
|
|
|
|
VOID OIDScrollRight(lpDataInfo,wColsToScroll)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wColsToScroll;
|
|
{
|
|
WORD locIndex;
|
|
INT locScrollSize;
|
|
RECT locRect;
|
|
|
|
if (lpDataInfo->diCurLeftCol + wColsToScroll > lpDataInfo->diLastColInData)
|
|
wColsToScroll = lpDataInfo->diLastColInData - lpDataInfo->diCurLeftCol;
|
|
|
|
if (wColsToScroll > 0)
|
|
{
|
|
locScrollSize = 0;
|
|
|
|
for (locIndex = 0; locIndex < wColsToScroll; locIndex++)
|
|
{
|
|
locScrollSize +=
|
|
OIDGetColWidth(lpDataInfo,lpDataInfo->diCurLeftCol+locIndex);
|
|
}
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locRect);
|
|
locRect.left += lpDataInfo->diRowHeaderWidth;
|
|
ScrollWindow(lpDataInfo->diGen.hWnd, -locScrollSize, 0, &locRect, &locRect);
|
|
lpDataInfo->diCurLeftCol += wColsToScroll;
|
|
|
|
OIDUpdateHorzScrollPos(lpDataInfo);
|
|
}
|
|
}
|
|
|
|
VOID OIDScrollUp(lpDataInfo,wRowsToScroll)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wRowsToScroll;
|
|
{
|
|
WORD locScrollSize;
|
|
WORD locIndex;
|
|
RECT locRect;
|
|
|
|
if ((DWORD)wRowsToScroll > lpDataInfo->diCurTopRow)
|
|
wRowsToScroll = (WORD)lpDataInfo->diCurTopRow;
|
|
|
|
if (wRowsToScroll > 0)
|
|
{
|
|
/*
|
|
| Calculate the height of these rows
|
|
*/
|
|
|
|
locScrollSize = 0;
|
|
|
|
for (locIndex = 0; locIndex < wRowsToScroll; locIndex++)
|
|
{
|
|
locScrollSize +=
|
|
OIDGetRowHeight(lpDataInfo,lpDataInfo->diCurTopRow-locIndex-1);
|
|
}
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locRect);
|
|
locRect.top += lpDataInfo->diColHeaderHeight;
|
|
ScrollWindow(lpDataInfo->diGen.hWnd,0,locScrollSize,&locRect,&locRect);
|
|
lpDataInfo->diCurTopRow -= wRowsToScroll;
|
|
|
|
OIDUpdateVertScrollPos(lpDataInfo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
| OIDcrollDataDown
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
VOID OIDScrollDown(lpDataInfo,wRowsToScroll)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wRowsToScroll;
|
|
{
|
|
INT locScrollSize;
|
|
WORD locIndex;
|
|
RECT locRect;
|
|
|
|
if (lpDataInfo->diCurTopRow + wRowsToScroll >= lpDataInfo->diLastRowInData)
|
|
{
|
|
wRowsToScroll = (WORD)(lpDataInfo->diLastRowInData - lpDataInfo->diCurTopRow);
|
|
}
|
|
|
|
if (wRowsToScroll > 0)
|
|
{
|
|
/*
|
|
| Calculate the height of these rows
|
|
*/
|
|
|
|
locScrollSize = 0;
|
|
|
|
for (locIndex = 0; locIndex < wRowsToScroll; locIndex++)
|
|
{
|
|
locScrollSize +=
|
|
OIDGetRowHeight(lpDataInfo,lpDataInfo->diCurTopRow+locIndex);
|
|
}
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locRect);
|
|
locRect.top += lpDataInfo->diColHeaderHeight;
|
|
ScrollWindow(lpDataInfo->diGen.hWnd,0,-locScrollSize,&locRect,&locRect);
|
|
lpDataInfo->diCurTopRow += wRowsToScroll;
|
|
|
|
OIDUpdateVertScrollPos(lpDataInfo);
|
|
}
|
|
}
|
|
|
|
VOID OIDPageDown(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
WORD locScrollSize;
|
|
WORD locIndex;
|
|
|
|
locScrollSize = 0;
|
|
locIndex = 0;
|
|
|
|
while (lpDataInfo->diCurTopRow + locIndex < lpDataInfo->diLastRowInData
|
|
&& locScrollSize < (WORD)lpDataInfo->diClientHeight)
|
|
{
|
|
locScrollSize += OIDGetRowHeight(lpDataInfo,lpDataInfo->diCurTopRow+locIndex);
|
|
locIndex++;
|
|
}
|
|
|
|
if (locIndex > 0)
|
|
{
|
|
lpDataInfo->diCurTopRow += locIndex;
|
|
InvalidateRect(lpDataInfo->diGen.hWnd,NULL,TRUE);
|
|
OIDUpdateVertScrollPos(lpDataInfo);
|
|
}
|
|
}
|
|
|
|
|
|
VOID OIDPageUp(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
WORD locScrollSize;
|
|
WORD locIndex;
|
|
|
|
locScrollSize = 0;
|
|
locIndex = 0;
|
|
|
|
while (lpDataInfo->diCurTopRow - locIndex > 0
|
|
&& locScrollSize < (WORD)lpDataInfo->diClientHeight)
|
|
{
|
|
locScrollSize +=
|
|
OIDGetRowHeight(lpDataInfo,lpDataInfo->diCurTopRow+locIndex);
|
|
locIndex++;
|
|
}
|
|
|
|
if (locIndex > 0)
|
|
{
|
|
lpDataInfo->diCurTopRow -= locIndex;
|
|
InvalidateRect(lpDataInfo->diGen.hWnd,NULL,TRUE);
|
|
OIDUpdateVertScrollPos(lpDataInfo);
|
|
}
|
|
}
|
|
|
|
VOID OIDPageRight(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
WORD locScrollSize;
|
|
WORD locIndex;
|
|
|
|
locScrollSize = 0;
|
|
locIndex = 0;
|
|
|
|
while (lpDataInfo->diCurLeftCol + locIndex < lpDataInfo->diLastColInData
|
|
&& locScrollSize < (WORD)lpDataInfo->diClientWidth)
|
|
{
|
|
locScrollSize += OIDGetColWidth(lpDataInfo,lpDataInfo->diCurLeftCol+locIndex);
|
|
locIndex++;
|
|
}
|
|
|
|
if (locIndex > 0)
|
|
{
|
|
lpDataInfo->diCurLeftCol += locIndex;
|
|
InvalidateRect(lpDataInfo->diGen.hWnd,NULL,TRUE);
|
|
OIDUpdateHorzScrollPos(lpDataInfo);
|
|
}
|
|
}
|
|
|
|
|
|
VOID OIDPageLeft(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
WORD locScrollSize;
|
|
WORD locIndex;
|
|
|
|
locScrollSize = 0;
|
|
locIndex = 0;
|
|
|
|
while (lpDataInfo->diCurLeftCol - locIndex > 0
|
|
&& locScrollSize < (WORD)lpDataInfo->diClientWidth)
|
|
{
|
|
locScrollSize +=
|
|
OIDGetColWidth(lpDataInfo,lpDataInfo->diCurLeftCol-locIndex);
|
|
locIndex++;
|
|
}
|
|
|
|
if (locIndex > 0)
|
|
{
|
|
lpDataInfo->diCurLeftCol -= locIndex;
|
|
InvalidateRect(lpDataInfo->diGen.hWnd,NULL,TRUE);
|
|
OIDUpdateHorzScrollPos(lpDataInfo);
|
|
}
|
|
}
|
|
|
|
/*
|
|
| Caret move routines
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
VOID OIDMoveCaret(lpDataInfo,hDC,wVirtualKey)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
WORD wVirtualKey;
|
|
{
|
|
/*
|
|
| If an area is selected, clear it and set the caret position
|
|
*/
|
|
|
|
OIDDrawSelection(lpDataInfo,hDC);
|
|
|
|
lpDataInfo->diSelectEndRow = lpDataInfo->diSelectAnchorRow;
|
|
lpDataInfo->diSelectEndCol = lpDataInfo->diSelectAnchorCol;
|
|
|
|
switch (wVirtualKey)
|
|
{
|
|
case VK_LEFT:
|
|
OIDMoveCaretLeft(lpDataInfo,hDC);
|
|
break;
|
|
case VK_UP:
|
|
OIDMoveCaretUp(lpDataInfo,hDC);
|
|
break;
|
|
case VK_RIGHT:
|
|
OIDMoveCaretRight(lpDataInfo,hDC);
|
|
break;
|
|
case VK_DOWN:
|
|
OIDMoveCaretDown(lpDataInfo,hDC);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ExcludeUpdateRgn(hDC,lpDataInfo->diGen.hWnd);
|
|
OIDDrawSelection(lpDataInfo,hDC);
|
|
UpdateWindow(lpDataInfo->diGen.hWnd);
|
|
}
|
|
|
|
|
|
|
|
|
|
VOID OIDMoveCaretLeft(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
|
|
if (lpDataInfo->diSelectAnchorCol > 0)
|
|
{
|
|
lpDataInfo->diSelectAnchorCol--;
|
|
lpDataInfo->diSelectEndCol = lpDataInfo->diSelectAnchorCol;
|
|
|
|
if (lpDataInfo->diSelectAnchorCol < lpDataInfo->diCurLeftCol)
|
|
{
|
|
OIDScrollLeft(lpDataInfo,1);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID OIDMoveCaretUp(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
if (lpDataInfo->diSelectAnchorRow > 0)
|
|
{
|
|
lpDataInfo->diSelectAnchorRow--;
|
|
lpDataInfo->diSelectEndRow = lpDataInfo->diSelectAnchorRow;
|
|
|
|
if (lpDataInfo->diSelectAnchorRow < lpDataInfo->diCurTopRow)
|
|
{
|
|
OIDScrollUp(lpDataInfo,1);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID OIDMoveCaretRight(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
RECT locClientRect;
|
|
RECT locCellRect;
|
|
WORD locCount;
|
|
WORD locCol;
|
|
|
|
if (lpDataInfo->diSelectAnchorCol < lpDataInfo->diLastColInData)
|
|
{
|
|
lpDataInfo->diSelectAnchorCol++;
|
|
lpDataInfo->diSelectEndCol = lpDataInfo->diSelectAnchorCol;
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locClientRect);
|
|
OIDMapCellToRect(lpDataInfo,lpDataInfo->diSelectAnchorCol,0,&locCellRect);
|
|
|
|
locCount = 0;
|
|
locCol = lpDataInfo->diCurLeftCol;
|
|
|
|
while (locCellRect.right > locClientRect.right && locCol <= lpDataInfo->diLastColInData && locCol < lpDataInfo->diSelectAnchorCol)
|
|
{
|
|
locClientRect.right += OIDGetColWidth(lpDataInfo,locCol);
|
|
locCount++;
|
|
locCol++;
|
|
}
|
|
|
|
if (locCount)
|
|
OIDScrollRight(lpDataInfo,locCount);
|
|
}
|
|
}
|
|
|
|
VOID OIDMoveCaretDown(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
if (lpDataInfo->diSelectAnchorRow < lpDataInfo->diLastRowInData)
|
|
{
|
|
lpDataInfo->diSelectAnchorRow++;
|
|
lpDataInfo->diSelectEndRow = lpDataInfo->diSelectAnchorRow;
|
|
|
|
if (lpDataInfo->diSelectAnchorRow >= lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo))
|
|
{
|
|
OIDScrollDown(lpDataInfo,1);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID OIDMoveEnd(lpDataInfo,hDC,wVirtualKey)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
WORD wVirtualKey;
|
|
{
|
|
switch (wVirtualKey)
|
|
{
|
|
case VK_LEFT:
|
|
OIDMoveEndLeft(lpDataInfo,hDC);
|
|
break;
|
|
case VK_UP:
|
|
OIDMoveEndUp(lpDataInfo,hDC);
|
|
break;
|
|
case VK_RIGHT:
|
|
OIDMoveEndRight(lpDataInfo,hDC);
|
|
break;
|
|
case VK_DOWN:
|
|
OIDMoveEndDown(lpDataInfo,hDC);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
VOID OIDMoveEndLeft(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
|
|
if (lpDataInfo->diSelectEndCol > 0)
|
|
{
|
|
if (lpDataInfo->diSelectEndCol-1 < lpDataInfo->diCurLeftCol)
|
|
{
|
|
OIDScrollLeft(lpDataInfo,1);
|
|
}
|
|
|
|
ExcludeUpdateRgn(hDC,lpDataInfo->diGen.hWnd);
|
|
OIDAddToSelection(lpDataInfo,hDC,lpDataInfo->diSelectEndRow,lpDataInfo->diSelectEndCol-1);
|
|
lpDataInfo->diSelectEndCol--;
|
|
}
|
|
}
|
|
|
|
VOID OIDMoveEndUp(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
if (lpDataInfo->diSelectEndRow > 0)
|
|
{
|
|
if (lpDataInfo->diSelectEndRow-1 < lpDataInfo->diCurTopRow)
|
|
{
|
|
OIDScrollUp(lpDataInfo,1);
|
|
}
|
|
|
|
ExcludeUpdateRgn(hDC,lpDataInfo->diGen.hWnd);
|
|
OIDAddToSelection(lpDataInfo,hDC,lpDataInfo->diSelectEndRow-1,lpDataInfo->diSelectEndCol);
|
|
lpDataInfo->diSelectEndRow--;
|
|
}
|
|
}
|
|
|
|
VOID OIDMoveEndRight(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
if (lpDataInfo->diSelectEndCol < lpDataInfo->diLastColInData)
|
|
{
|
|
while (lpDataInfo->diSelectEndCol+1 >= lpDataInfo->diCurLeftCol + OIDVisibleCols(lpDataInfo))
|
|
{
|
|
OIDScrollRight(lpDataInfo,1);
|
|
}
|
|
|
|
ExcludeUpdateRgn(hDC,lpDataInfo->diGen.hWnd);
|
|
OIDAddToSelection(lpDataInfo,hDC,lpDataInfo->diSelectEndRow,lpDataInfo->diSelectEndCol+1);
|
|
lpDataInfo->diSelectEndCol++;
|
|
}
|
|
}
|
|
|
|
VOID OIDMoveEndDown(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
if (lpDataInfo->diSelectEndRow < lpDataInfo->diLastRowInData)
|
|
{
|
|
if (lpDataInfo->diSelectEndRow+1 >= lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo))
|
|
{
|
|
OIDScrollDown(lpDataInfo,1);
|
|
}
|
|
|
|
ExcludeUpdateRgn(hDC,lpDataInfo->diGen.hWnd);
|
|
OIDAddToSelection(lpDataInfo,hDC,lpDataInfo->diSelectEndRow+1,lpDataInfo->diSelectEndCol);
|
|
lpDataInfo->diSelectEndRow++;
|
|
}
|
|
}
|
|
|
|
WORD OIDVisibleCols(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
RECT locRect;
|
|
int locX; /* Right edge in DC of locCol */
|
|
WORD locCol;
|
|
|
|
locCol = lpDataInfo->diCurLeftCol;
|
|
locX = lpDataInfo->diRowHeaderWidth;
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locRect);
|
|
|
|
while (locX < locRect.right && locCol <= lpDataInfo->diLastColInData)
|
|
{
|
|
locX += OIDGetColWidth(lpDataInfo,locCol);
|
|
locCol++;
|
|
}
|
|
|
|
if (locX >= locRect.right) locCol--;
|
|
|
|
return(max(locCol - lpDataInfo->diCurLeftCol,1));
|
|
}
|
|
|
|
WORD OIDVisibleRows(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
RECT locRect;
|
|
int locY;
|
|
DWORD locRow;
|
|
|
|
locY = lpDataInfo->diColHeaderHeight;
|
|
locRow = lpDataInfo->diCurTopRow;
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locRect);
|
|
|
|
while (locY < locRect.bottom && locRow <= lpDataInfo->diLastRowInData)
|
|
{
|
|
locY += OIDGetRowHeight(lpDataInfo,locRow);
|
|
locRow++;
|
|
}
|
|
|
|
if (locY >= locRect.bottom) locRow--;
|
|
|
|
return((WORD)(locRow - lpDataInfo->diCurTopRow));
|
|
}
|
|
|
|
/*
|
|
|
|
|
|
|
|
|
|
|
| Selection Routines
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
VOID OIDSelectAll(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
UTSetCursor(UTCURSOR_BUSY);
|
|
|
|
while (!(lpDataInfo->diFlags & OIDF_SIZEKNOWN))
|
|
{
|
|
SccDebugOut("\r\n Forced Read Ahead");
|
|
SendMessage(GetParent(lpDataInfo->diGen.hWnd),SCCD_READMEAHEAD,0,0);
|
|
}
|
|
|
|
OIDSetSelection(lpDataInfo,0,0,lpDataInfo->diLastRowInData,lpDataInfo->diLastColInData);
|
|
|
|
UTSetCursor(UTCURSOR_NORMAL);
|
|
}
|
|
|
|
VOID OIDSetSelection(lpDataInfo,dwAnchorRow,wAnchorCol,dwEndRow,wEndCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
DWORD dwAnchorRow;
|
|
WORD wAnchorCol;
|
|
DWORD dwEndRow;
|
|
WORD wEndCol;
|
|
{
|
|
OIDDrawSelection(lpDataInfo,NULL);
|
|
|
|
lpDataInfo->diSelectMode = OIDSELECT_BLOCK;
|
|
|
|
lpDataInfo->diSelectAnchorRow = dwAnchorRow;
|
|
lpDataInfo->diSelectEndRow = dwEndRow;
|
|
|
|
lpDataInfo->diSelectAnchorCol = wAnchorCol;
|
|
lpDataInfo->diSelectEndCol = wEndCol;
|
|
|
|
OIDDrawSelection(lpDataInfo,NULL);
|
|
}
|
|
|
|
VOID OIDMakeAnchorVisible(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
if (lpDataInfo->diSelectAnchorRow < lpDataInfo->diCurTopRow)
|
|
{
|
|
OIDScrollUp(lpDataInfo,(WORD)(lpDataInfo->diCurTopRow - lpDataInfo->diSelectAnchorRow));
|
|
}
|
|
|
|
if (lpDataInfo->diSelectAnchorCol < lpDataInfo->diCurLeftCol)
|
|
{
|
|
OIDScrollLeft(lpDataInfo,lpDataInfo->diCurLeftCol - lpDataInfo->diSelectAnchorCol);
|
|
}
|
|
|
|
if (lpDataInfo->diSelectAnchorRow > lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo) - 1)
|
|
{
|
|
OIDScrollDown(lpDataInfo,(WORD)(lpDataInfo->diSelectAnchorRow - (lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo) - 1)));
|
|
}
|
|
|
|
if (lpDataInfo->diSelectAnchorCol > lpDataInfo->diCurLeftCol + OIDVisibleCols(lpDataInfo) - 1)
|
|
{
|
|
OIDScrollRight(lpDataInfo,lpDataInfo->diSelectAnchorCol - (lpDataInfo->diCurLeftCol + OIDVisibleCols(lpDataInfo) - 1));
|
|
}
|
|
}
|
|
|
|
VOID OIDStartSelection(lpDataInfo,hDC,wX,wY)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
int wX;
|
|
int wY;
|
|
{
|
|
DWORD locRow;
|
|
WORD locCol;
|
|
WORD locMapResult;
|
|
|
|
OIDDrawSelection(lpDataInfo,hDC);
|
|
|
|
locMapResult = OIDMapXyToCell(lpDataInfo,wX,wY,&locCol,&locRow);
|
|
|
|
if (locMapResult == 0)
|
|
{
|
|
/*
|
|
| Regular selection
|
|
*/
|
|
|
|
lpDataInfo->diSelectAnchorRow =
|
|
lpDataInfo->diSelectEndRow = locRow;
|
|
|
|
lpDataInfo->diSelectAnchorCol =
|
|
lpDataInfo->diSelectEndCol = locCol;
|
|
|
|
lpDataInfo->diSelectMode = OIDSELECT_BLOCK;
|
|
|
|
OIDDrawSelection(lpDataInfo,hDC);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
| Column selection
|
|
*/
|
|
|
|
if (locMapResult & OIDF_INCOLHEADER)
|
|
{
|
|
lpDataInfo->diSelectMode = OIDSELECT_COLS;
|
|
|
|
lpDataInfo->diSelectColCnt = 0;
|
|
lpDataInfo->diSelectColLimit = 20;
|
|
|
|
OIDAddColSelect(lpDataInfo,hDC,locCol,TRUE);
|
|
}
|
|
else if (locMapResult & OIDF_INROWHEADER)
|
|
{
|
|
lpDataInfo->diSelectMode = OIDSELECT_ROWS;
|
|
|
|
lpDataInfo->diSelectRowCnt = 0;
|
|
lpDataInfo->diSelectRowLimit = 20;
|
|
|
|
OIDAddRowSelect(lpDataInfo,hDC,locRow,TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID OIDUpdateSelection(lpDataInfo,hDC,wX,wY,bFirst)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
int wX;
|
|
int wY;
|
|
BOOL bFirst;
|
|
{
|
|
DWORD locRow;
|
|
WORD locCol;
|
|
WORD locMapResult;
|
|
|
|
OIDAutoScrollCheck(lpDataInfo,hDC,&wX,&wY);
|
|
|
|
locMapResult = OIDMapXyToCell(lpDataInfo,wX,wY,&locCol,&locRow);
|
|
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_BLOCK)
|
|
{
|
|
OIDAddToSelection(lpDataInfo,hDC,locRow,locCol);
|
|
lpDataInfo->diSelectEndRow = locRow;
|
|
lpDataInfo->diSelectEndCol = locCol;
|
|
}
|
|
else if (lpDataInfo->diSelectMode & OIDSELECT_COLS)
|
|
{
|
|
if (bFirst && locMapResult & OIDF_INROWHEADER)
|
|
{
|
|
if (!(lpDataInfo->diSelectMode & OIDSELECT_CROSS))
|
|
{
|
|
OIDDrawSelection(lpDataInfo,hDC);
|
|
lpDataInfo->diSelectRowCnt = 0;
|
|
lpDataInfo->diSelectRowLimit = 20;
|
|
lpDataInfo->diSelectMode = OIDSELECT_ROWS | OIDSELECT_CROSS;
|
|
OIDDrawSelection(lpDataInfo,hDC);
|
|
}
|
|
lpDataInfo->diSelectMode = OIDSELECT_ROWS | OIDSELECT_CROSS;
|
|
OIDAddRowSelect(lpDataInfo,hDC,locRow,bFirst);
|
|
}
|
|
else
|
|
{
|
|
OIDAddColSelect(lpDataInfo,hDC,locCol,bFirst);
|
|
}
|
|
}
|
|
else if (lpDataInfo->diSelectMode & OIDSELECT_ROWS)
|
|
{
|
|
if (bFirst && locMapResult & OIDF_INCOLHEADER)
|
|
{
|
|
if (!(lpDataInfo->diSelectMode & OIDSELECT_CROSS))
|
|
{
|
|
OIDDrawSelection(lpDataInfo,hDC);
|
|
lpDataInfo->diSelectColCnt = 0;
|
|
lpDataInfo->diSelectColLimit = 20;
|
|
lpDataInfo->diSelectMode = OIDSELECT_COLS | OIDSELECT_CROSS;
|
|
OIDDrawSelection(lpDataInfo,hDC);
|
|
}
|
|
lpDataInfo->diSelectMode = OIDSELECT_COLS | OIDSELECT_CROSS;
|
|
OIDAddColSelect(lpDataInfo,hDC,locCol,bFirst);
|
|
}
|
|
else
|
|
{
|
|
OIDAddRowSelect(lpDataInfo,hDC,locRow,bFirst);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID OIDAddColSelect(lpDataInfo,hDC,wCol,bFirst)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
WORD wCol;
|
|
BOOL bFirst;
|
|
{
|
|
OIDUPDATE locColUpdate;
|
|
|
|
if (bFirst)
|
|
{
|
|
lpDataInfo->diSelectAnchorCol = wCol;
|
|
lpDataInfo->diSelectEndCol = wCol;
|
|
|
|
if (!OIInvertRange(wCol, wCol, lpDataInfo->diSelectCols , &lpDataInfo->diSelectColCnt, lpDataInfo->diSelectColLimit))
|
|
{
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_CROSS)
|
|
OIDInvertCrossCols(lpDataInfo,hDC,wCol,wCol);
|
|
else
|
|
OIDInvertCols(lpDataInfo,hDC,wCol,wCol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OIDGenUpdate(&locColUpdate,wCol,lpDataInfo->diSelectEndCol,lpDataInfo->diSelectAnchorCol);
|
|
|
|
if (locColUpdate.DoAdd)
|
|
{
|
|
if (!OIInvertRange(locColUpdate.AddA,locColUpdate.AddB, lpDataInfo->diSelectCols , &lpDataInfo->diSelectColCnt, lpDataInfo->diSelectColLimit))
|
|
{
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_CROSS)
|
|
OIDInvertCrossCols(lpDataInfo,hDC,locColUpdate.AddA,locColUpdate.AddB);
|
|
else
|
|
OIDInvertCols(lpDataInfo,hDC,locColUpdate.AddA,locColUpdate.AddB);
|
|
}
|
|
}
|
|
|
|
if (locColUpdate.DoDel)
|
|
{
|
|
if (!OIInvertRange(locColUpdate.DelA,locColUpdate.DelB, lpDataInfo->diSelectCols , &lpDataInfo->diSelectColCnt, lpDataInfo->diSelectColLimit))
|
|
{
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_CROSS)
|
|
OIDInvertCrossCols(lpDataInfo,hDC,locColUpdate.DelA,locColUpdate.DelB);
|
|
else
|
|
OIDInvertCols(lpDataInfo,hDC,locColUpdate.DelA,locColUpdate.DelB);
|
|
}
|
|
}
|
|
|
|
lpDataInfo->diSelectEndCol = wCol;
|
|
}
|
|
}
|
|
|
|
VOID OIDAddRowSelect(lpDataInfo,hDC,dwRow,bFirst)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRow;
|
|
BOOL bFirst;
|
|
{
|
|
OIDUPDATE locRowUpdate;
|
|
|
|
if (bFirst)
|
|
{
|
|
lpDataInfo->diSelectAnchorRow = dwRow;
|
|
lpDataInfo->diSelectEndRow = dwRow;
|
|
|
|
if (!OIInvertRange(dwRow, dwRow, lpDataInfo->diSelectRows , &lpDataInfo->diSelectRowCnt, lpDataInfo->diSelectRowLimit))
|
|
{
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_CROSS)
|
|
OIDInvertCrossRows(lpDataInfo,hDC,dwRow,dwRow);
|
|
else
|
|
OIDInvertRows(lpDataInfo,hDC,dwRow,dwRow);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OIDGenUpdate(&locRowUpdate,dwRow,lpDataInfo->diSelectEndRow,lpDataInfo->diSelectAnchorRow);
|
|
|
|
if (locRowUpdate.DoAdd)
|
|
{
|
|
if (!OIInvertRange(locRowUpdate.AddA,locRowUpdate.AddB, lpDataInfo->diSelectRows , &lpDataInfo->diSelectRowCnt, lpDataInfo->diSelectRowLimit))
|
|
{
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_CROSS)
|
|
OIDInvertCrossRows(lpDataInfo,hDC,locRowUpdate.AddA,locRowUpdate.AddB);
|
|
else
|
|
OIDInvertRows(lpDataInfo,hDC,locRowUpdate.AddA,locRowUpdate.AddB);
|
|
}
|
|
}
|
|
|
|
if (locRowUpdate.DoDel)
|
|
{
|
|
if (!OIInvertRange(locRowUpdate.DelA,locRowUpdate.DelB, lpDataInfo->diSelectRows , &lpDataInfo->diSelectRowCnt, lpDataInfo->diSelectRowLimit))
|
|
{
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_CROSS)
|
|
OIDInvertCrossRows(lpDataInfo,hDC,locRowUpdate.DelA,locRowUpdate.DelB);
|
|
else
|
|
OIDInvertRows(lpDataInfo,hDC,locRowUpdate.DelA,locRowUpdate.DelB);
|
|
}
|
|
}
|
|
|
|
lpDataInfo->diSelectEndRow = dwRow;
|
|
}
|
|
}
|
|
|
|
VOID OIDAutoScrollCheck(lpDataInfo,hDC,pX,pY)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HWND hDC;
|
|
int FAR * pX;
|
|
int FAR * pY;
|
|
{
|
|
RECT locRect;
|
|
WORD locRowsToScroll;
|
|
|
|
UTFlagOff(lpDataInfo->diFlags,OIDF_BACKDRAGSCROLL);
|
|
|
|
GetClientRect(lpDataInfo->diGen.hWnd,&locRect);
|
|
|
|
if (*pY > locRect.bottom)
|
|
{
|
|
locRowsToScroll = (*pY-locRect.bottom) / lpDataInfo->diDefRowHeight;
|
|
locRowsToScroll++;
|
|
|
|
if (locRowsToScroll != 0)
|
|
{
|
|
OIDScrollDown(lpDataInfo,locRowsToScroll);
|
|
UpdateWindow(lpDataInfo->diGen.hWnd);
|
|
*pY = locRect.bottom;
|
|
UTFlagOn(lpDataInfo->diFlags,OIDF_BACKDRAGSCROLL);
|
|
SccBkBackgroundOn(lpDataInfo->diGen.hWnd,2);
|
|
}
|
|
}
|
|
else if (*pY < locRect.top)
|
|
{
|
|
locRowsToScroll = (locRect.top-*pY) / lpDataInfo->diDefRowHeight;
|
|
locRowsToScroll++;
|
|
|
|
if (locRowsToScroll != 0)
|
|
{
|
|
OIDScrollUp(lpDataInfo,locRowsToScroll);
|
|
UpdateWindow(lpDataInfo->diGen.hWnd);
|
|
*pY = locRect.top;
|
|
UTFlagOn(lpDataInfo->diFlags,OIDF_BACKDRAGSCROLL);
|
|
SccBkBackgroundOn(lpDataInfo->diGen.hWnd,2);
|
|
}
|
|
}
|
|
|
|
if (*pX > locRect.right)
|
|
{
|
|
OIDScrollRight(lpDataInfo,1);
|
|
UpdateWindow(lpDataInfo->diGen.hWnd);
|
|
*pX = locRect.right;
|
|
UTFlagOn(lpDataInfo->diFlags,OIDF_BACKDRAGSCROLL);
|
|
SccBkBackgroundOn(lpDataInfo->diGen.hWnd,2);
|
|
}
|
|
else if (*pX < locRect.left)
|
|
{
|
|
OIDScrollLeft(lpDataInfo,1);
|
|
UpdateWindow(lpDataInfo->diGen.hWnd);
|
|
*pX = locRect.left;
|
|
UTFlagOn(lpDataInfo->diFlags,OIDF_BACKDRAGSCROLL);
|
|
SccBkBackgroundOn(lpDataInfo->diGen.hWnd,2);
|
|
}
|
|
}
|
|
|
|
|
|
VOID OIDGenUpdate(lpUpdate,dwSel,dwCur,dwAnchor)
|
|
LPOIDUPDATE lpUpdate;
|
|
LONG dwSel;
|
|
LONG dwCur;
|
|
LONG dwAnchor;
|
|
{
|
|
LONG locDeltaCur;
|
|
LONG locDeltaSel;
|
|
|
|
register DWORD locTemp;
|
|
|
|
LONG locDirCur;
|
|
LONG locDirSel;
|
|
|
|
lpUpdate->CurA = dwAnchor;
|
|
lpUpdate->CurB = dwCur;
|
|
|
|
lpUpdate->ResultA = dwAnchor;
|
|
lpUpdate->ResultB = dwSel;
|
|
|
|
locDeltaCur = dwCur - dwAnchor;
|
|
locDeltaSel = dwSel - dwAnchor;
|
|
|
|
if (locDeltaCur < 0)
|
|
locDirCur = -1;
|
|
else if (locDeltaCur > 0)
|
|
locDirCur = 1;
|
|
else
|
|
locDirCur = 0;
|
|
|
|
if (locDeltaSel < 0)
|
|
locDirSel = -1;
|
|
else if (locDeltaSel > 0)
|
|
locDirSel = 1;
|
|
else
|
|
locDirSel = 0;
|
|
|
|
lpUpdate->CurDir = locDirCur;
|
|
lpUpdate->SelDir = locDirSel;
|
|
|
|
if (locDeltaCur == locDeltaSel)
|
|
{
|
|
lpUpdate->DoDel = FALSE;
|
|
lpUpdate->DoAdd = FALSE;
|
|
|
|
lpUpdate->UnchangedA = dwAnchor;
|
|
lpUpdate->UnchangedB = dwCur;
|
|
}
|
|
else if (locDeltaCur == 0)
|
|
{
|
|
lpUpdate->DoDel = FALSE;
|
|
lpUpdate->DoAdd = TRUE;
|
|
|
|
lpUpdate->AddA = dwSel;
|
|
lpUpdate->AddB = dwAnchor + locDirSel;
|
|
|
|
lpUpdate->UnchangedA = dwAnchor;
|
|
lpUpdate->UnchangedB = dwAnchor;
|
|
}
|
|
else if (locDeltaSel == 0)
|
|
{
|
|
lpUpdate->DoAdd = FALSE;
|
|
lpUpdate->DoDel = TRUE;
|
|
|
|
lpUpdate->DelA = dwCur;
|
|
lpUpdate->DelB = dwAnchor + locDirCur;
|
|
|
|
lpUpdate->UnchangedA = dwAnchor;
|
|
lpUpdate->UnchangedB = dwAnchor;
|
|
}
|
|
else if (locDirCur != locDirSel)
|
|
{
|
|
lpUpdate->DoAdd = TRUE;
|
|
lpUpdate->DoDel = TRUE;
|
|
|
|
lpUpdate->DelA = dwCur;
|
|
lpUpdate->DelB = dwAnchor + locDirCur;
|
|
|
|
lpUpdate->AddA = dwSel;
|
|
lpUpdate->AddB = dwAnchor + locDirSel;
|
|
|
|
lpUpdate->UnchangedA = dwAnchor;
|
|
lpUpdate->UnchangedB = dwAnchor;
|
|
}
|
|
else if (labs(locDeltaCur) < labs(locDeltaSel))
|
|
{
|
|
lpUpdate->DoAdd = TRUE;
|
|
lpUpdate->DoDel = FALSE;
|
|
|
|
lpUpdate->AddA = dwSel;
|
|
lpUpdate->AddB = dwCur + locDirSel;
|
|
|
|
lpUpdate->UnchangedA = dwAnchor;
|
|
lpUpdate->UnchangedB = dwCur;
|
|
}
|
|
else if (labs(locDeltaCur) > labs(locDeltaSel))
|
|
{
|
|
lpUpdate->DoAdd = FALSE;
|
|
lpUpdate->DoDel = TRUE;
|
|
|
|
lpUpdate->DelA = dwCur;
|
|
lpUpdate->DelB = dwSel + locDirCur;
|
|
|
|
lpUpdate->UnchangedA = dwAnchor;
|
|
lpUpdate->UnchangedB = dwSel;
|
|
}
|
|
else
|
|
{
|
|
lpUpdate->DoDel = FALSE;
|
|
lpUpdate->DoAdd = FALSE;
|
|
}
|
|
|
|
if (lpUpdate->CurA > lpUpdate->CurB)
|
|
{
|
|
locTemp = lpUpdate->CurA;
|
|
lpUpdate->CurA = lpUpdate->CurB;
|
|
lpUpdate->CurB = locTemp;
|
|
}
|
|
|
|
if (lpUpdate->ResultA > lpUpdate->ResultB)
|
|
{
|
|
locTemp = lpUpdate->ResultA;
|
|
lpUpdate->ResultA = lpUpdate->ResultB;
|
|
lpUpdate->ResultB = locTemp;
|
|
}
|
|
|
|
if (lpUpdate->UnchangedA > lpUpdate->UnchangedB)
|
|
{
|
|
locTemp = lpUpdate->UnchangedA;
|
|
lpUpdate->UnchangedA = lpUpdate->UnchangedB;
|
|
lpUpdate->UnchangedB = locTemp;
|
|
}
|
|
|
|
if (lpUpdate->DoAdd && lpUpdate->AddA > lpUpdate->AddB)
|
|
{
|
|
locTemp = lpUpdate->AddA;
|
|
lpUpdate->AddA = lpUpdate->AddB;
|
|
lpUpdate->AddB = locTemp;
|
|
}
|
|
|
|
if (lpUpdate->DoDel && lpUpdate->DelA > lpUpdate->DelB)
|
|
{
|
|
locTemp = lpUpdate->DelA;
|
|
lpUpdate->DelA = lpUpdate->DelB;
|
|
lpUpdate->DelB = locTemp;
|
|
}
|
|
}
|
|
|
|
BOOL OIDFixRangeToVisible(pA,pB,dwTop,dwBottom)
|
|
DWORD FAR * pA;
|
|
DWORD FAR * pB;
|
|
DWORD dwTop;
|
|
DWORD dwBottom;
|
|
{
|
|
int locADir;
|
|
int locBDir;
|
|
|
|
if (*pA < dwTop)
|
|
locADir = -1;
|
|
else if (*pA > dwBottom)
|
|
locADir = 1;
|
|
else
|
|
locADir = 0;
|
|
|
|
if (*pB < dwTop)
|
|
locBDir = -1;
|
|
else if (*pB > dwBottom)
|
|
locBDir = 1;
|
|
else
|
|
locBDir = 0;
|
|
|
|
if (locADir * locBDir != 1)
|
|
{
|
|
if (locADir == -1)
|
|
*pA = dwTop;
|
|
else if (locADir == 1)
|
|
*pA = dwBottom;
|
|
|
|
if (locBDir == -1)
|
|
*pB = dwTop;
|
|
else if (locBDir == 1)
|
|
*pB = dwBottom;
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
|
|
VOID OIDAddToSelection(lpDataInfo,hDC,dwRow,wCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRow;
|
|
WORD wCol;
|
|
{
|
|
OIDUPDATE locRowUpdate;
|
|
OIDUPDATE locColUpdate;
|
|
|
|
DWORD locTopRow;
|
|
DWORD locLeftCol;
|
|
DWORD locBottomRow;
|
|
DWORD locRightCol;
|
|
|
|
BOOL locUnchangedVis;
|
|
BOOL locCurVis;
|
|
BOOL locResultVis;
|
|
BOOL locRowAddVis;
|
|
BOOL locRowDelVis;
|
|
BOOL locColAddVis;
|
|
BOOL locColDelVis;
|
|
|
|
OIDGenUpdate(&locRowUpdate,dwRow,lpDataInfo->diSelectEndRow,lpDataInfo->diSelectAnchorRow);
|
|
OIDGenUpdate(&locColUpdate,wCol,lpDataInfo->diSelectEndCol,lpDataInfo->diSelectAnchorCol);
|
|
|
|
locTopRow = lpDataInfo->diCurTopRow;
|
|
locLeftCol = lpDataInfo->diCurLeftCol;
|
|
locBottomRow = locTopRow + OIDVisibleRows(lpDataInfo);
|
|
locRightCol = locLeftCol + OIDVisibleCols(lpDataInfo);
|
|
|
|
locUnchangedVis = OIDFixRangeToVisible(&locRowUpdate.UnchangedA,&locRowUpdate.UnchangedB,locTopRow,locBottomRow);
|
|
|
|
locCurVis = OIDFixRangeToVisible(&locColUpdate.CurA,&locColUpdate.CurB,locLeftCol,locRightCol);
|
|
|
|
locResultVis = OIDFixRangeToVisible(&locColUpdate.ResultA,&locColUpdate.ResultB,locLeftCol,locRightCol);
|
|
|
|
if (locRowUpdate.DoAdd)
|
|
{
|
|
locRowAddVis = OIDFixRangeToVisible(&locRowUpdate.AddA,&locRowUpdate.AddB,locTopRow,locBottomRow);
|
|
}
|
|
|
|
if (locColUpdate.DoAdd)
|
|
{
|
|
locColAddVis = OIDFixRangeToVisible(&locColUpdate.AddA,&locColUpdate.AddB,locLeftCol,locRightCol);
|
|
}
|
|
|
|
if (locRowUpdate.DoDel)
|
|
{
|
|
locRowDelVis = OIDFixRangeToVisible(&locRowUpdate.DelA,&locRowUpdate.DelB,locTopRow,locBottomRow);
|
|
}
|
|
|
|
if (locColUpdate.DoDel)
|
|
{
|
|
locColDelVis = OIDFixRangeToVisible(&locColUpdate.DelA,&locColUpdate.DelB,locLeftCol,locRightCol);
|
|
}
|
|
|
|
/*
|
|
| Unchanged Rows X Deleted Columns
|
|
*/
|
|
|
|
if (locColUpdate.DoDel && locUnchangedVis && locColDelVis)
|
|
{
|
|
OIDInvertArea(lpDataInfo,hDC,locRowUpdate.UnchangedA,locColUpdate.DelA,locRowUpdate.UnchangedB,locColUpdate.DelB,locColUpdate.CurDir == -1 ? OIDF_ANCHORRIGHT : OIDF_ANCHORLEFT);
|
|
}
|
|
|
|
/*
|
|
| Deleted Rows X Current Columns
|
|
*/
|
|
|
|
if (locRowUpdate.DoDel && locRowDelVis && locCurVis)
|
|
{
|
|
OIDInvertArea(lpDataInfo,hDC,locRowUpdate.DelA,locColUpdate.CurA,locRowUpdate.DelB,locColUpdate.CurB,locRowUpdate.CurDir == -1 ? OIDF_ANCHORBOTTOM : OIDF_ANCHORTOP);
|
|
}
|
|
|
|
/*
|
|
| Unchanged Rows X Added Columns
|
|
*/
|
|
|
|
if (locColUpdate.DoAdd && locUnchangedVis && locColAddVis)
|
|
{
|
|
OIDInvertArea(lpDataInfo,hDC,locRowUpdate.UnchangedA,locColUpdate.AddA,locRowUpdate.UnchangedB,locColUpdate.AddB,locColUpdate.SelDir == -1 ? OIDF_ANCHORRIGHT : OIDF_ANCHORLEFT);
|
|
}
|
|
|
|
/*
|
|
| Added Rows X Resulting Columns
|
|
*/
|
|
|
|
if (locRowUpdate.DoAdd && locRowAddVis && locResultVis)
|
|
{
|
|
OIDInvertArea(lpDataInfo,hDC,locRowUpdate.AddA,locColUpdate.ResultA,locRowUpdate.AddB,locColUpdate.ResultB,locRowUpdate.SelDir == -1 ? OIDF_ANCHORBOTTOM : OIDF_ANCHORTOP);
|
|
}
|
|
|
|
}
|
|
|
|
VOID OIDEndSelection(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
UTFlagOff(lpDataInfo->diFlags,OIDF_BACKDRAGSCROLL);
|
|
}
|
|
|
|
WORD OIDMapSelectToRealCol(lpDataInfo,dwCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
DWORD dwCol;
|
|
{
|
|
WORD locIndex;
|
|
DWORD locCount;
|
|
DWORD locNewCount;
|
|
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_BLOCK)
|
|
{
|
|
return((WORD)dwCol);
|
|
}
|
|
else if (lpDataInfo->diSelectMode & (OIDSELECT_CROSS | OIDSELECT_COLS))
|
|
{
|
|
locCount = 0;
|
|
|
|
for (locIndex = 0; locIndex < lpDataInfo->diSelectColCnt; locIndex++)
|
|
{
|
|
locNewCount = locCount + lpDataInfo->diSelectCols[locIndex].dwEndPos - lpDataInfo->diSelectCols[locIndex].dwStartPos + 1;
|
|
|
|
if (dwCol < locNewCount)
|
|
{
|
|
return((WORD)(dwCol - locCount + lpDataInfo->diSelectCols[locIndex].dwStartPos));
|
|
}
|
|
|
|
locCount = locNewCount;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return((WORD)dwCol);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
DWORD OIDMapSelectToRealRow(lpDataInfo,dwRow)
|
|
LPOIDATAINFO lpDataInfo;
|
|
DWORD dwRow;
|
|
{
|
|
WORD locIndex;
|
|
DWORD locCount;
|
|
DWORD locNewCount;
|
|
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_BLOCK)
|
|
{
|
|
return(dwRow);
|
|
}
|
|
else if (lpDataInfo->diSelectMode & (OIDSELECT_CROSS | OIDSELECT_ROWS))
|
|
{
|
|
locCount = 0;
|
|
|
|
for (locIndex = 0; locIndex < lpDataInfo->diSelectRowCnt; locIndex++)
|
|
{
|
|
locNewCount = locCount + lpDataInfo->diSelectRows[locIndex].dwEndPos - lpDataInfo->diSelectRows[locIndex].dwStartPos + 1;
|
|
|
|
if (dwRow < locNewCount)
|
|
{
|
|
return(dwRow - locCount + lpDataInfo->diSelectRows[locIndex].dwStartPos);
|
|
}
|
|
|
|
locCount = locNewCount;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return(dwRow);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
VOID OIDDoBackground(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
POINT ptData;
|
|
|
|
if (lpDataInfo->diFlags & OIDF_BACKDRAGSCROLL)
|
|
{
|
|
GetCursorPos(&ptData);
|
|
ScreenToClient(lpDataInfo->diGen.hWnd,&ptData);
|
|
SendMessage(lpDataInfo->diGen.hWnd,WM_MOUSEMOVE,NULL,MAKELONG(ptData.x,ptData.y));
|
|
}
|
|
else
|
|
{
|
|
SccBkBackgroundOff(lpDataInfo->diGen.hWnd);
|
|
}
|
|
}
|
|
|
|
|
|
VOID OIDInvertArea(lpDataInfo,hDC,dwTopRow,dwLeftCol,dwBottomRow,dwRightCol,wFlags)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwTopRow;
|
|
DWORD dwLeftCol;
|
|
DWORD dwBottomRow;
|
|
DWORD dwRightCol;
|
|
WORD wFlags;
|
|
{
|
|
RECT locTopLeft;
|
|
RECT locBottomRight;
|
|
|
|
OIDMapCellToRect(lpDataInfo,(WORD) dwLeftCol, dwTopRow, &locTopLeft);
|
|
OIDMapCellToRect(lpDataInfo,(WORD) dwRightCol, dwBottomRow, &locBottomRight);
|
|
|
|
if (!(wFlags & OIDF_NOBORDER))
|
|
{
|
|
locTopLeft.left -= 2;
|
|
locTopLeft.top -= 2;
|
|
locBottomRight.right += 1;
|
|
locBottomRight.bottom += 1;
|
|
|
|
if (dwTopRow == lpDataInfo->diCurTopRow)
|
|
locTopLeft.top += 2;
|
|
else if (wFlags & OIDF_ANCHORTOP)
|
|
locTopLeft.top += 3;
|
|
|
|
if (dwLeftCol == lpDataInfo->diCurLeftCol)
|
|
locTopLeft.left += 2;
|
|
else if (wFlags & OIDF_ANCHORLEFT)
|
|
locTopLeft.left += 3;
|
|
|
|
if (wFlags & OIDF_ANCHORRIGHT)
|
|
locBottomRight.right -= 3;
|
|
|
|
if (wFlags & OIDF_ANCHORBOTTOM)
|
|
locBottomRight.bottom -= 3;
|
|
}
|
|
|
|
BitBlt(hDC,
|
|
locTopLeft.left,
|
|
locTopLeft.top,
|
|
locBottomRight.right - locTopLeft.left,
|
|
locBottomRight.bottom - locTopLeft.top,
|
|
NULL,0,0,
|
|
DSTINVERT);
|
|
}
|
|
|
|
VOID OIDInvertCols(lpDataInfo,hDC,dwLeftCol,dwRightCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwLeftCol;
|
|
DWORD dwRightCol;
|
|
{
|
|
RECT locTopLeft;
|
|
RECT locBottomRight;
|
|
DWORD locLastRow;
|
|
|
|
if (dwRightCol < lpDataInfo->diCurLeftCol || dwLeftCol > lpDataInfo->diCurLeftCol + OIDVisibleCols(lpDataInfo))
|
|
return;
|
|
|
|
if (dwLeftCol < lpDataInfo->diCurLeftCol)
|
|
dwLeftCol = lpDataInfo->diCurLeftCol;
|
|
|
|
locLastRow = min(lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo),lpDataInfo->diLastRowInData);
|
|
|
|
OIDMapCellToRect(lpDataInfo,(WORD) dwLeftCol, lpDataInfo->diCurTopRow, &locTopLeft);
|
|
OIDMapCellToRect(lpDataInfo,(WORD) dwRightCol, locLastRow, &locBottomRight);
|
|
|
|
locTopLeft.top -= lpDataInfo->diColHeaderHeight;
|
|
|
|
BitBlt(hDC,
|
|
locTopLeft.left,
|
|
locTopLeft.top,
|
|
locBottomRight.right - locTopLeft.left,
|
|
locBottomRight.bottom - locTopLeft.top,
|
|
NULL,0,0,
|
|
DSTINVERT);
|
|
}
|
|
|
|
VOID OIDInvertCrossCols(lpDataInfo,hDC,dwLeftCol,dwRightCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwLeftCol;
|
|
DWORD dwRightCol;
|
|
{
|
|
WORD locRowIndex;
|
|
DWORD locTopRow;
|
|
DWORD locBottomRow;
|
|
|
|
OIDInvertColHeaders(lpDataInfo,hDC,(WORD)dwLeftCol,(WORD)dwRightCol);
|
|
|
|
for (locRowIndex = 0; locRowIndex < lpDataInfo->diSelectRowCnt; locRowIndex++)
|
|
{
|
|
locTopRow = lpDataInfo->diSelectRows[locRowIndex].dwStartPos;
|
|
locBottomRow = lpDataInfo->diSelectRows[locRowIndex].dwEndPos;
|
|
|
|
if (locBottomRow < lpDataInfo->diCurTopRow || locTopRow > lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo))
|
|
continue;
|
|
|
|
if (locTopRow < lpDataInfo->diCurTopRow)
|
|
locTopRow = lpDataInfo->diCurTopRow;
|
|
|
|
OIDInvertArea(lpDataInfo,
|
|
hDC,
|
|
locTopRow,
|
|
dwLeftCol,
|
|
locBottomRow,
|
|
dwRightCol,
|
|
OIDF_NOBORDER);
|
|
}
|
|
}
|
|
|
|
VOID OIDInvertRows(lpDataInfo,hDC,dwTopRow,dwBottomRow)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwTopRow;
|
|
DWORD dwBottomRow;
|
|
{
|
|
RECT locTopLeft;
|
|
RECT locBottomRight;
|
|
WORD locLastCol;
|
|
|
|
if (dwBottomRow < lpDataInfo->diCurTopRow || dwTopRow > lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo))
|
|
return;
|
|
|
|
if (dwTopRow < lpDataInfo->diCurTopRow)
|
|
dwTopRow = lpDataInfo->diCurTopRow;
|
|
|
|
locLastCol = min(lpDataInfo->diCurLeftCol + OIDVisibleCols(lpDataInfo),lpDataInfo->diLastColInData);
|
|
|
|
OIDMapCellToRect(lpDataInfo, lpDataInfo->diCurLeftCol, dwTopRow, &locTopLeft);
|
|
OIDMapCellToRect(lpDataInfo, locLastCol, dwBottomRow, &locBottomRight);
|
|
|
|
locTopLeft.left -= lpDataInfo->diRowHeaderWidth;
|
|
|
|
BitBlt(hDC,
|
|
locTopLeft.left,
|
|
locTopLeft.top,
|
|
locBottomRight.right - locTopLeft.left,
|
|
locBottomRight.bottom - locTopLeft.top,
|
|
NULL,0,0,
|
|
DSTINVERT);
|
|
}
|
|
|
|
VOID OIDInvertCrossRows(lpDataInfo,hDC,dwTopRow,dwBottomRow)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwTopRow;
|
|
DWORD dwBottomRow;
|
|
{
|
|
WORD locColIndex;
|
|
DWORD locLeftCol;
|
|
DWORD locRightCol;
|
|
|
|
OIDInvertRowHeaders(lpDataInfo,hDC,dwTopRow,dwBottomRow);
|
|
|
|
for (locColIndex = 0; locColIndex < lpDataInfo->diSelectColCnt; locColIndex++)
|
|
{
|
|
locLeftCol = lpDataInfo->diSelectCols[locColIndex].dwStartPos;
|
|
locRightCol = lpDataInfo->diSelectCols[locColIndex].dwEndPos;
|
|
|
|
if (locRightCol < lpDataInfo->diCurLeftCol || locLeftCol > lpDataInfo->diCurLeftCol + OIDVisibleCols(lpDataInfo))
|
|
continue;
|
|
|
|
if (locLeftCol < lpDataInfo->diCurLeftCol)
|
|
locLeftCol = lpDataInfo->diCurLeftCol;
|
|
|
|
OIDInvertArea(lpDataInfo,
|
|
hDC,
|
|
dwTopRow,
|
|
locLeftCol,
|
|
dwBottomRow,
|
|
locRightCol,
|
|
OIDF_NOBORDER);
|
|
}
|
|
}
|
|
|
|
VOID OIDInvertColHeaders(lpDataInfo,hDC,wStartCol,wEndCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
WORD wStartCol;
|
|
WORD wEndCol;
|
|
{
|
|
RECT locTopLeft;
|
|
RECT locBottomRight;
|
|
RECT locRect;
|
|
|
|
OIDMapCellToRect(lpDataInfo, wStartCol, 0, &locTopLeft);
|
|
OIDMapCellToRect(lpDataInfo, wEndCol, 0, &locBottomRight);
|
|
|
|
locRect.left = locTopLeft.left;
|
|
locRect.right = locBottomRight.right;
|
|
locRect.top = 0;
|
|
locRect.bottom = lpDataInfo->diColHeaderHeight;
|
|
|
|
BitBlt(hDC,
|
|
locRect.left,
|
|
locRect.top,
|
|
locRect.right - locRect.left,
|
|
locRect.bottom - locRect.top,
|
|
NULL,0,0,
|
|
DSTINVERT);
|
|
}
|
|
|
|
VOID OIDInvertRowHeaders(lpDataInfo,hDC,dwStartRow,dwEndRow)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwStartRow;
|
|
DWORD dwEndRow;
|
|
{
|
|
RECT locTopLeft;
|
|
RECT locBottomRight;
|
|
RECT locRect;
|
|
|
|
OIDMapCellToRect(lpDataInfo, 0, dwStartRow, &locTopLeft);
|
|
OIDMapCellToRect(lpDataInfo, 0, dwEndRow, &locBottomRight);
|
|
|
|
locRect.top = locTopLeft.top;
|
|
locRect.bottom = locBottomRight.bottom;
|
|
locRect.left = 0;
|
|
locRect.right = lpDataInfo->diRowHeaderWidth;
|
|
|
|
BitBlt(hDC,
|
|
locRect.left,
|
|
locRect.top,
|
|
locRect.right - locRect.left,
|
|
locRect.bottom - locRect.top,
|
|
NULL,0,0,
|
|
DSTINVERT);
|
|
}
|
|
|
|
|
|
VOID OIDInvertCell(lpDataInfo,hDC,dwRow,wCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRow;
|
|
WORD wCol;
|
|
{
|
|
RECT locRect;
|
|
|
|
// if ((dwRow != lpDataInfo->diSelectAnchorRow || wCol != lpDataInfo->diSelectAnchorCol) && dwRow >= lpDataInfo->diCurTopRow && wCol >= lpDataInfo->diCurLeftCol)
|
|
// {
|
|
OIDMapCellToRect(lpDataInfo,wCol,dwRow,&locRect);
|
|
InvertRect(hDC,&locRect);
|
|
// }
|
|
}
|
|
|
|
VOID OIDDrawSelection(lpDataInfo,hDC)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
{
|
|
HDC locDC;
|
|
DWORD locEndRow;
|
|
WORD locEndCol;
|
|
|
|
WORD locRowIndex;
|
|
WORD locColIndex;
|
|
WORD locLeftCol;
|
|
WORD locRightCol;
|
|
DWORD locTopRow;
|
|
DWORD locBottomRow;
|
|
|
|
if (hDC == NULL)
|
|
{
|
|
locDC = lpDataInfo->diDC = GetDC(lpDataInfo->diGen.hWnd);
|
|
UTFlagOn(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
ExcludeUpdateRgn(locDC,lpDataInfo->diGen.hWnd);
|
|
}
|
|
else
|
|
{
|
|
locDC = hDC;
|
|
}
|
|
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_BLOCK)
|
|
{
|
|
OIDDrawCaret(lpDataInfo,locDC,lpDataInfo->diSelectAnchorRow,lpDataInfo->diSelectAnchorCol);
|
|
|
|
locEndRow = lpDataInfo->diSelectEndRow;
|
|
locEndCol = lpDataInfo->diSelectEndCol;
|
|
|
|
lpDataInfo->diSelectEndRow = lpDataInfo->diSelectAnchorRow;
|
|
lpDataInfo->diSelectEndCol = lpDataInfo->diSelectAnchorCol;
|
|
|
|
OIDAddToSelection(lpDataInfo,locDC,locEndRow,locEndCol);
|
|
|
|
lpDataInfo->diSelectEndRow = locEndRow;
|
|
lpDataInfo->diSelectEndCol = locEndCol;
|
|
}
|
|
else if (lpDataInfo->diSelectMode & OIDSELECT_CROSS)
|
|
{
|
|
/*
|
|
| Invert column headers
|
|
*/
|
|
|
|
for (locColIndex = 0; locColIndex < lpDataInfo->diSelectColCnt; locColIndex++)
|
|
{
|
|
locLeftCol = (WORD)lpDataInfo->diSelectCols[locColIndex].dwStartPos;
|
|
locRightCol = (WORD)lpDataInfo->diSelectCols[locColIndex].dwEndPos;
|
|
|
|
if (locRightCol < lpDataInfo->diCurLeftCol || locLeftCol > lpDataInfo->diCurLeftCol + OIDVisibleCols(lpDataInfo))
|
|
continue;
|
|
|
|
if (locLeftCol < lpDataInfo->diCurLeftCol)
|
|
locLeftCol = lpDataInfo->diCurLeftCol;
|
|
|
|
OIDInvertColHeaders(lpDataInfo,hDC,locLeftCol,locRightCol);
|
|
}
|
|
|
|
/*
|
|
| Invert row headers
|
|
*/
|
|
|
|
for (locRowIndex = 0; locRowIndex < lpDataInfo->diSelectRowCnt; locRowIndex++)
|
|
{
|
|
locTopRow = lpDataInfo->diSelectRows[locRowIndex].dwStartPos;
|
|
locBottomRow = lpDataInfo->diSelectRows[locRowIndex].dwEndPos;
|
|
|
|
if (locBottomRow < lpDataInfo->diCurTopRow || locTopRow > lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo))
|
|
continue;
|
|
|
|
if (locTopRow < lpDataInfo->diCurTopRow)
|
|
locTopRow = lpDataInfo->diCurTopRow;
|
|
|
|
OIDInvertRowHeaders(lpDataInfo,hDC,locTopRow,locBottomRow);
|
|
}
|
|
|
|
/*
|
|
| Invert intersections
|
|
*/
|
|
|
|
for (locColIndex = 0; locColIndex < lpDataInfo->diSelectColCnt; locColIndex++)
|
|
{
|
|
locLeftCol = (WORD)lpDataInfo->diSelectCols[locColIndex].dwStartPos;
|
|
locRightCol = (WORD)lpDataInfo->diSelectCols[locColIndex].dwEndPos;
|
|
|
|
/*
|
|
| Fixup cols to visible area
|
|
*/
|
|
|
|
if (locRightCol < lpDataInfo->diCurLeftCol || locLeftCol > lpDataInfo->diCurLeftCol + OIDVisibleCols(lpDataInfo))
|
|
continue;
|
|
|
|
if (locLeftCol < lpDataInfo->diCurLeftCol)
|
|
locLeftCol = lpDataInfo->diCurLeftCol;
|
|
|
|
/*
|
|
| Run through rows
|
|
*/
|
|
|
|
for (locRowIndex = 0; locRowIndex < lpDataInfo->diSelectRowCnt; locRowIndex++)
|
|
{
|
|
/*
|
|
| Fixup rows to visible area
|
|
*/
|
|
|
|
locTopRow = lpDataInfo->diSelectRows[locRowIndex].dwStartPos;
|
|
locBottomRow = lpDataInfo->diSelectRows[locRowIndex].dwEndPos;
|
|
|
|
if (locBottomRow < lpDataInfo->diCurTopRow || locTopRow > lpDataInfo->diCurTopRow + OIDVisibleRows(lpDataInfo))
|
|
continue;
|
|
|
|
if (locTopRow < lpDataInfo->diCurTopRow)
|
|
locTopRow = lpDataInfo->diCurTopRow;
|
|
|
|
/*
|
|
| Invert cross section
|
|
*/
|
|
|
|
OIDInvertArea(lpDataInfo,
|
|
locDC,
|
|
locTopRow,
|
|
locLeftCol,
|
|
locBottomRow,
|
|
locRightCol,
|
|
OIDF_NOBORDER);
|
|
}
|
|
}
|
|
}
|
|
else if (lpDataInfo->diSelectMode & OIDSELECT_COLS)
|
|
{
|
|
for (locColIndex = 0; locColIndex < lpDataInfo->diSelectColCnt; locColIndex++)
|
|
{
|
|
OIDInvertCols(lpDataInfo,locDC,lpDataInfo->diSelectCols[locColIndex].dwStartPos,lpDataInfo->diSelectCols[locColIndex].dwEndPos);
|
|
}
|
|
}
|
|
else if (lpDataInfo->diSelectMode & OIDSELECT_ROWS)
|
|
{
|
|
for (locRowIndex = 0; locRowIndex < lpDataInfo->diSelectRowCnt; locRowIndex++)
|
|
{
|
|
OIDInvertRows(lpDataInfo,locDC,lpDataInfo->diSelectRows[locRowIndex].dwStartPos,lpDataInfo->diSelectRows[locRowIndex].dwEndPos);
|
|
}
|
|
}
|
|
|
|
if (hDC == NULL)
|
|
{
|
|
UTFlagOff(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
ReleaseDC(lpDataInfo->diGen.hWnd,locDC);
|
|
}
|
|
}
|
|
|
|
/*
|
|
|
|
|
|
|
|
| Focus control
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
VOID OIDSetFocus(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
// OIDShowCaret(lpDataInfo);
|
|
}
|
|
|
|
VOID OIDKillFocus(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
// OIDHideCaret(lpDataInfo);
|
|
}
|
|
|
|
VOID OIDUpdateVertScrollPos(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
WORD locPos;
|
|
|
|
if (lpDataInfo->diLastRowInData == 0)
|
|
locPos = 0;
|
|
else
|
|
locPos = (WORD)((lpDataInfo->diCurTopRow * 0x1000) / lpDataInfo->diLastRowInData);
|
|
|
|
SetScrollPos(lpDataInfo->diGen.hVertScroll,SB_CTL,locPos,TRUE);
|
|
}
|
|
|
|
VOID OIDUpdateHorzScrollPos(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
WORD locPos;
|
|
|
|
if (lpDataInfo->diLastColInData == 0)
|
|
locPos = 0;
|
|
else
|
|
locPos = (WORD)(((DWORD)lpDataInfo->diCurLeftCol * 0x1000) / (DWORD)lpDataInfo->diLastColInData);
|
|
|
|
SetScrollPos(lpDataInfo->diGen.hHorzScroll,SB_CTL,locPos,TRUE);
|
|
}
|
|
|
|
|
|
VOID OIDShowCaret(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
if (!(lpDataInfo->diFlags & OIDF_CARETVISIBLE))
|
|
{
|
|
OIDDrawSelection(lpDataInfo,NULL);
|
|
|
|
UTFlagOn(lpDataInfo->diFlags,OIDF_CARETVISIBLE);
|
|
}
|
|
}
|
|
|
|
VOID OIDHideCaret(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
if (lpDataInfo->diFlags & OIDF_CARETVISIBLE)
|
|
{
|
|
OIDDrawSelection(lpDataInfo,NULL);
|
|
|
|
UTFlagOff(lpDataInfo->diFlags,OIDF_CARETVISIBLE);
|
|
}
|
|
}
|
|
|
|
VOID OIDDrawCaret(lpDataInfo,hDC,dwRow,wCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
HDC hDC;
|
|
DWORD dwRow;
|
|
WORD wCol;
|
|
{
|
|
RECT locRect;
|
|
WORD locTop;
|
|
WORD locLeft;
|
|
WORD locHeight;
|
|
WORD locWidth;
|
|
|
|
if (dwRow >= lpDataInfo->diCurTopRow && wCol >= lpDataInfo->diCurLeftCol)
|
|
{
|
|
OIDMapCellToRect(lpDataInfo,wCol,dwRow,&locRect);
|
|
|
|
locTop = locRect.top + 1;
|
|
locHeight = locRect.bottom - locRect.top - 3;
|
|
locLeft = locRect.left - 2;
|
|
locWidth = 3;
|
|
|
|
if (wCol == lpDataInfo->diCurLeftCol)
|
|
{
|
|
locLeft += 2;
|
|
locWidth = 1;
|
|
}
|
|
|
|
BitBlt(hDC,locLeft,locTop,locWidth,locHeight,NULL,0,0,DSTINVERT);
|
|
|
|
locLeft = locRect.right - 2;
|
|
locWidth = 3;
|
|
|
|
BitBlt(hDC,locLeft,locTop,locWidth,locHeight,NULL,0,0,DSTINVERT);
|
|
|
|
locTop = locRect.top - 2;
|
|
locHeight = 3;
|
|
locLeft = locRect.left - 2;
|
|
locWidth = locRect.right - locRect.left + 3;
|
|
|
|
if (wCol == lpDataInfo->diCurLeftCol)
|
|
{
|
|
locLeft += 2;
|
|
locWidth -= 2;
|
|
}
|
|
|
|
if (dwRow == lpDataInfo->diCurTopRow)
|
|
{
|
|
locTop += 2;
|
|
locHeight = 1;
|
|
}
|
|
|
|
BitBlt(hDC,locLeft,locTop,locWidth,locHeight,NULL,0,0,DSTINVERT);
|
|
|
|
locTop = locRect.bottom - 2;
|
|
locHeight = 3;
|
|
|
|
BitBlt(hDC,locLeft,locTop,locWidth,locHeight,NULL,0,0,DSTINVERT);
|
|
}
|
|
}
|
|
|
|
WORD OIDGetRowHeight(lpDataInfo,dwRow)
|
|
LPOIDATAINFO lpDataInfo;
|
|
DWORD dwRow;
|
|
{
|
|
return(lpDataInfo->diDefRowHeight);
|
|
}
|
|
|
|
/*
|
|
| Get the column width in DC based on Display font
|
|
*/
|
|
|
|
WORD OIDGetColWidth(lpDataInfo,wCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wCol;
|
|
{
|
|
SOFIELD FAR * lpFieldInfo;
|
|
WORD locWidth;
|
|
WORD locCharCnt;
|
|
|
|
|
|
lpFieldInfo = (SOFIELD FAR *) GlobalLock(lpDataInfo->diFieldInfo);
|
|
|
|
locCharCnt = max((int)lpFieldInfo[wCol].dwWidth,(int)lstrlen(lpFieldInfo[wCol].szName));
|
|
|
|
locWidth = locCharCnt * lpDataInfo->diFontAvgWidth * 3 / 2;
|
|
locWidth += locWidth % 2;
|
|
|
|
GlobalUnlock(lpDataInfo->diFieldInfo);
|
|
return(locWidth);
|
|
}
|
|
|
|
WORD OIDGetColWidthInChars(lpDataInfo,wCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wCol;
|
|
{
|
|
SOFIELD FAR * lpFieldInfo;
|
|
WORD locWidth;
|
|
|
|
lpFieldInfo = (SOFIELD FAR *) GlobalLock(lpDataInfo->diFieldInfo);
|
|
locWidth = (WORD)lpFieldInfo[wCol].dwWidth;
|
|
GlobalUnlock(lpDataInfo->diFieldInfo);
|
|
return(locWidth);
|
|
}
|
|
|
|
/*
|
|
| Get the column width in Twips based on Clipboard font
|
|
*/
|
|
|
|
DWORD OIDGetColWidthInTwips(lpDataInfo,wCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wCol;
|
|
{
|
|
SOFIELD FAR * lpFieldInfo;
|
|
DWORD locWidth;
|
|
|
|
lpFieldInfo = (SOFIELD FAR *) GlobalLock(lpDataInfo->diFieldInfo);
|
|
locWidth = lpFieldInfo[wCol].dwWidth * gDbOp.sFontInfo.TextMetric.tmAveCharWidth * lpDataInfo->diTwipsPerDC * 3 / 2;
|
|
locWidth += locWidth % 2;
|
|
GlobalUnlock(lpDataInfo->diFieldInfo);
|
|
return(locWidth);
|
|
}
|
|
|
|
WORD OIDScanForRow(lpDataInfo,dwRow)
|
|
LPOIDATAINFO lpDataInfo;
|
|
DWORD dwRow;
|
|
{
|
|
if (dwRow > lpDataInfo->diLastRowInData)
|
|
return(0);
|
|
else
|
|
return(1);
|
|
}
|
|
|
|
/*
|
|
| Rendering
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
VOID OIDCopyToClip(lpDataInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
{
|
|
DWORD locStartRow;
|
|
DWORD locEndRow;
|
|
DWORD locStartCol;
|
|
DWORD locEndCol;
|
|
|
|
if (!OIDGetSelectedRange(lpDataInfo,&locStartRow,&locEndRow,&locStartCol,&locEndCol))
|
|
return;
|
|
|
|
/*
|
|
| Render selected types to the Clipboard
|
|
*/
|
|
|
|
if (OpenClipboard(lpDataInfo->diGen.hWnd))
|
|
{
|
|
EmptyClipboard();
|
|
|
|
if (gDbOp.wFormats & DBOP_FORMAT_RTF)
|
|
OIDRenderRtf(lpDataInfo,locStartRow,locEndRow,(WORD)locStartCol,(WORD)locEndCol,TRUE);
|
|
|
|
if (gDbOp.wFormats & DBOP_FORMAT_AMI2)
|
|
OIDRenderAmi2(lpDataInfo,locStartRow,locEndRow,(WORD)locStartCol,(WORD)locEndCol);
|
|
|
|
if (gDbOp.wFormats & DBOP_FORMAT_AMI)
|
|
OIDRenderAmi(lpDataInfo,locStartRow,locEndRow,(WORD)locStartCol,(WORD)locEndCol);
|
|
|
|
if (gDbOp.wFormats & DBOP_FORMAT_PROWRITE)
|
|
OIDRenderProWritePlus(lpDataInfo,locStartRow,locEndRow,(WORD)locStartCol,(WORD)locEndCol);
|
|
|
|
if (gDbOp.wFormats & DBOP_FORMAT_WORDSTAR)
|
|
OIDRenderWordStar(lpDataInfo,locStartRow,locEndRow,(WORD)locStartCol,(WORD)locEndCol);
|
|
|
|
if (gDbOp.wFormats & DBOP_FORMAT_LEGACY)
|
|
OIDRenderLegacy(lpDataInfo,locStartRow,locEndRow,(WORD)locStartCol,(WORD)locEndCol);
|
|
|
|
if (gDbOp.wFormats & DBOP_FORMAT_TEXT)
|
|
OIDRenderText(lpDataInfo,locStartRow,locEndRow,(WORD)locStartCol,(WORD)locEndCol);
|
|
|
|
CloseClipboard();
|
|
}
|
|
}
|
|
|
|
LONG OIDRenderRtfToFile(lpDataInfo,lpFile)
|
|
LPOIDATAINFO lpDataInfo;
|
|
LPSTR lpFile;
|
|
{
|
|
HANDLE locDataHnd;
|
|
LPSTR locDataPtr;
|
|
int locFileHnd;
|
|
DWORD locSize;
|
|
|
|
while (!(lpDataInfo->diFlags & OIDF_SIZEKNOWN))
|
|
{
|
|
SccDebugOut("\r\n Forced Read Ahead");
|
|
SendMessage(GetParent(lpDataInfo->diGen.hWnd),SCCD_READMEAHEAD,0,0);
|
|
}
|
|
|
|
locDataHnd = OIDRenderRtf(lpDataInfo,0,lpDataInfo->diLastRowInData,0,lpDataInfo->diLastColInData,FALSE);
|
|
|
|
if (locDataHnd)
|
|
{
|
|
locSize = GlobalSize(locDataHnd);
|
|
locDataPtr = GlobalLock(locDataHnd);
|
|
|
|
if (locDataPtr)
|
|
{
|
|
locFileHnd = _lcreat(lpFile,0);
|
|
|
|
if (locFileHnd != -1)
|
|
{
|
|
while (locSize > 10240)
|
|
{
|
|
_lwrite(locFileHnd,locDataPtr,10240);
|
|
locDataPtr += 10240;
|
|
locSize -= 10240;
|
|
}
|
|
|
|
if (locSize > 0)
|
|
{
|
|
_lwrite(locFileHnd,locDataPtr,(WORD)locSize);
|
|
}
|
|
|
|
_lclose(locFileHnd);
|
|
}
|
|
|
|
GlobalUnlock(locDataHnd);
|
|
GlobalFree(locDataHnd);
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
| OIDGetSelectedRange
|
|
|
|
|
| Generates a range based on the current selection
|
|
| for the Rendering & Printing routines. Row & Col numbers in
|
|
| the range must be run through MapSelectToReal to produce
|
|
| real Row & Col numbers
|
|
*/
|
|
|
|
BOOL OIDGetSelectedRange(lpDataInfo,lpStartRow,lpEndRow,lpStartCol,lpEndCol)
|
|
LPOIDATAINFO lpDataInfo;
|
|
DWORD FAR * lpStartRow;
|
|
DWORD FAR * lpEndRow;
|
|
DWORD FAR * lpStartCol;
|
|
DWORD FAR * lpEndCol;
|
|
{
|
|
WORD locIndex;
|
|
BOOL locRet;
|
|
|
|
locRet = TRUE;
|
|
|
|
/*
|
|
| Generate range based on selection type
|
|
*/
|
|
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_BLOCK)
|
|
{
|
|
*lpStartRow = OIDataSelectTopRow;
|
|
*lpEndRow = OIDataSelectBottomRow;
|
|
*lpStartCol = OIDataSelectLeftCol;
|
|
*lpEndCol = OIDataSelectRightCol;
|
|
}
|
|
else
|
|
{
|
|
if (lpDataInfo->diSelectMode & (OIDSELECT_CROSS | OIDSELECT_COLS))
|
|
{
|
|
if (lpDataInfo->diSelectColCnt)
|
|
{
|
|
*lpStartCol = 0;
|
|
*lpEndCol = 0;
|
|
|
|
for (locIndex = 0; locIndex < lpDataInfo->diSelectColCnt; locIndex++)
|
|
{
|
|
*lpEndCol += lpDataInfo->diSelectCols[locIndex].dwEndPos - lpDataInfo->diSelectCols[locIndex].dwStartPos + 1;
|
|
}
|
|
|
|
*lpEndCol -= 1;
|
|
}
|
|
else
|
|
{
|
|
locRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*lpStartCol = 0;
|
|
*lpEndCol = lpDataInfo->diLastColInData;
|
|
}
|
|
|
|
if (lpDataInfo->diSelectMode & (OIDSELECT_CROSS | OIDSELECT_ROWS))
|
|
{
|
|
if (lpDataInfo->diSelectRowCnt)
|
|
{
|
|
*lpStartRow = 0;
|
|
*lpEndRow = 0;
|
|
|
|
for (locIndex = 0; locIndex < lpDataInfo->diSelectRowCnt; locIndex++)
|
|
{
|
|
*lpEndRow += lpDataInfo->diSelectRows[locIndex].dwEndPos - lpDataInfo->diSelectRows[locIndex].dwStartPos + 1;
|
|
}
|
|
|
|
*lpEndRow -= 1;
|
|
}
|
|
else
|
|
{
|
|
locRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*lpStartRow = 0;
|
|
*lpEndRow = lpDataInfo->diLastRowInData;
|
|
}
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
/*
|
|
| Keyboard control
|
|
|
|
|
*/
|
|
|
|
VOID OIDHandleKeyEvent(lpDataInfo,wKey)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wKey;
|
|
{
|
|
HDC locDC;
|
|
|
|
switch (wKey)
|
|
{
|
|
case VK_LEFT:
|
|
case VK_UP:
|
|
case VK_RIGHT:
|
|
case VK_DOWN:
|
|
locDC = lpDataInfo->diDC = GetDC(lpDataInfo->diGen.hWnd);
|
|
UTFlagOn(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
ExcludeUpdateRgn(locDC,lpDataInfo->diGen.hWnd);
|
|
|
|
if (GetKeyState(VK_SHIFT) < 0)
|
|
OIDMoveEnd(lpDataInfo,locDC,wKey);
|
|
else
|
|
OIDMoveCaret(lpDataInfo,locDC,wKey);
|
|
|
|
UTFlagOff(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
ReleaseDC(lpDataInfo->diGen.hWnd,locDC);
|
|
break;
|
|
case VK_PRIOR:
|
|
OIDPageUp(lpDataInfo);
|
|
break;
|
|
case VK_NEXT:
|
|
OIDPageDown(lpDataInfo);
|
|
break;
|
|
case VK_TAB:
|
|
SetFocus(GetParent(lpDataInfo->diGen.hWnd));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
| Mouse control
|
|
|
|
|
*/
|
|
|
|
VOID OIDHandleMouseEvent(lpDataInfo,wMessage,wKeyInfo,wX,wY)
|
|
LPOIDATAINFO lpDataInfo;
|
|
WORD wMessage;
|
|
WORD wKeyInfo;
|
|
int wX;
|
|
int wY;
|
|
{
|
|
HDC locDC;
|
|
|
|
if (wMessage == WM_MOUSEMOVE)
|
|
{
|
|
if (lpDataInfo->diMouseFlags & OIDF_MOUSELEFTACTIVE)
|
|
{
|
|
locDC = lpDataInfo->diDC = GetDC(lpDataInfo->diGen.hWnd);
|
|
UTFlagOn(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
|
|
ExcludeUpdateRgn(locDC,lpDataInfo->diGen.hWnd);
|
|
|
|
OIDUpdateSelection(lpDataInfo,locDC,wX,wY,FALSE);
|
|
|
|
UTFlagOff(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
ReleaseDC(lpDataInfo->diGen.hWnd,locDC);
|
|
}
|
|
return;
|
|
}
|
|
|
|
switch (wMessage)
|
|
{
|
|
case WM_LBUTTONDOWN:
|
|
|
|
UTFlagOn(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTSINGLE);
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTDOUBLE);
|
|
|
|
if (!(lpDataInfo->diMouseFlags & OIDF_MOUSERIGHTACTIVE))
|
|
{
|
|
UTFlagOn(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTACTIVE);
|
|
|
|
if (lpDataInfo->diGen.hWnd != GetFocus())
|
|
SetFocus(lpDataInfo->diGen.hWnd);
|
|
|
|
SetCapture(lpDataInfo->diGen.hWnd);
|
|
UTFlagOn(lpDataInfo->diErrorFlags,OIDF_RELEASEMOUSE);
|
|
|
|
locDC = lpDataInfo->diDC = GetDC(lpDataInfo->diGen.hWnd);
|
|
UTFlagOn(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
|
|
ExcludeUpdateRgn(locDC,lpDataInfo->diGen.hWnd);
|
|
|
|
if (wKeyInfo & MK_SHIFT)
|
|
{
|
|
OIDUpdateSelection(lpDataInfo,locDC,wX,wY,FALSE);
|
|
}
|
|
else if (wKeyInfo & MK_CONTROL)
|
|
{
|
|
if (lpDataInfo->diSelectMode & OIDSELECT_BLOCK)
|
|
OIDStartSelection(lpDataInfo,locDC,wX,wY);
|
|
else
|
|
OIDUpdateSelection(lpDataInfo,locDC,wX,wY,TRUE);
|
|
}
|
|
else
|
|
{
|
|
OIDStartSelection(lpDataInfo,locDC,wX,wY);
|
|
}
|
|
|
|
UTFlagOff(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
ReleaseDC(lpDataInfo->diGen.hWnd,locDC);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_LBUTTONDBLCLK:
|
|
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTSINGLE);
|
|
UTFlagOn(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTDOUBLE);
|
|
|
|
if (!(lpDataInfo->diMouseFlags & OIDF_MOUSERIGHTACTIVE))
|
|
{
|
|
UTFlagOn(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTACTIVE);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
|
|
if (lpDataInfo->diMouseFlags & OIDF_MOUSELEFTACTIVE)
|
|
{
|
|
locDC = lpDataInfo->diDC = GetDC(lpDataInfo->diGen.hWnd);
|
|
UTFlagOn(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
|
|
ExcludeUpdateRgn(locDC,lpDataInfo->diGen.hWnd);
|
|
|
|
OIDUpdateSelection(lpDataInfo,locDC,wX,wY,FALSE);
|
|
|
|
UTFlagOff(lpDataInfo->diErrorFlags,OIDF_RELEASEDC);
|
|
ReleaseDC(lpDataInfo->diGen.hWnd,locDC);
|
|
|
|
OIDEndSelection(lpDataInfo);
|
|
|
|
UTFlagOff(lpDataInfo->diErrorFlags,OIDF_RELEASEMOUSE);
|
|
ReleaseCapture();
|
|
}
|
|
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTACTIVE);
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTSINGLE);
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSELEFTDOUBLE);
|
|
|
|
break;
|
|
|
|
case WM_RBUTTONDOWN:
|
|
|
|
UTFlagOn(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTSINGLE);
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTDOUBLE);
|
|
|
|
if (!(lpDataInfo->diMouseFlags & OIDF_MOUSELEFTACTIVE))
|
|
{
|
|
UTFlagOn(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTACTIVE);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_RBUTTONDBLCLK:
|
|
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTSINGLE);
|
|
UTFlagOn(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTDOUBLE);
|
|
|
|
if (!(lpDataInfo->diMouseFlags & OIDF_MOUSELEFTACTIVE))
|
|
{
|
|
UTFlagOn(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTACTIVE);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_RBUTTONUP:
|
|
|
|
if (lpDataInfo->diMouseFlags & OIDF_MOUSERIGHTACTIVE)
|
|
{
|
|
}
|
|
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTACTIVE);
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTSINGLE);
|
|
UTFlagOff(lpDataInfo->diMouseFlags,OIDF_MOUSERIGHTDOUBLE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
LONG OIDDoPrint(lpDataInfo,lpPrintInfo)
|
|
LPOIDATAINFO lpDataInfo;
|
|
LPSCCDPRINTINFO lpPrintInfo;
|
|
{
|
|
LONG locRet;
|
|
|
|
DWORD locStartRow;
|
|
DWORD locEndRow;
|
|
DWORD locStartCol;
|
|
DWORD locEndCol;
|
|
|
|
|
|
if (lpPrintInfo->piWholeDoc)
|
|
{
|
|
while (!(lpDataInfo->diFlags & OIDF_SIZEKNOWN))
|
|
{
|
|
SccDebugOut("\r\n Forced Read Ahead");
|
|
SendMessage(GetParent(lpDataInfo->diGen.hWnd),SCCD_READMEAHEAD,0,0);
|
|
}
|
|
|
|
locRet = (LONG) OIDPrint(lpDataInfo,0,lpDataInfo->diLastRowInData,0,lpDataInfo->diLastColInData,lpPrintInfo);
|
|
}
|
|
else
|
|
{
|
|
if (OIDGetSelectedRange(lpDataInfo,&locStartRow,&locEndRow,&locStartCol,&locEndCol))
|
|
locRet = (LONG) OIDPrint(lpDataInfo,locStartRow,locEndRow,(WORD)locStartCol,(WORD)locEndCol,lpPrintInfo);
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|
|
BOOL OIDDoOption(lpOpInfo)
|
|
LPSCCDOPTIONINFO lpOpInfo;
|
|
{
|
|
BOOL locRet;
|
|
|
|
locRet = FALSE;
|
|
|
|
switch (lpOpInfo->dwType)
|
|
{
|
|
case SCCD_OPDISPLAY:
|
|
locRet = DialogBoxParam(hInst, MAKEINTRESOURCE(200), lpOpInfo->hParentWnd, OIDbDisplayOpDlgProc, (DWORD)(LPOIDBOP)&gDbOp);
|
|
break;
|
|
case SCCD_OPPRINT:
|
|
locRet = DialogBoxParam(hInst, MAKEINTRESOURCE(300), lpOpInfo->hParentWnd, OIDbPrintOpDlgProc, (DWORD)(LPOIDBOP)&gDbOp);
|
|
break;
|
|
case SCCD_OPCLIPBOARD:
|
|
locRet = DialogBoxParam(hInst, MAKEINTRESOURCE(100), lpOpInfo->hParentWnd, OIDbClipboardOpDlgProc, (DWORD)(LPOIDBOP)&gDbOp);
|
|
break;
|
|
}
|
|
|
|
return(locRet);
|
|
}
|
|
|