/************************************************
OnPaint
Paints the corner button object. The corner button object uses a CUGCell
located at position -1,-1 from the default datasource then uses the cell
type associated with this cell to draw itself with.
Params:
<none>
Return:
<none>
*************************************************/
void CUGCnrBtn::OnPaint()
{
if ( m_GI->m_paintMode == FALSE )
return;
CPaintDC dc(this); // device context for painting
m_ctrl->OnScreenDCSetup(&dc,NULL,UG_TOPHEADING);
RECT rect;
GetClientRect(&rect);
CUGCellType * cellType;
CUGCell cell;
m_ctrl->GetCellIndirect(-1,-1,&cell);
//get the cell type to draw the cell
if(cell.IsPropertySet(UGCELL_CELLTYPE_SET))
cellType = m_ctrl->GetCellType(cell.GetCellType());
else
cellType = m_ctrl->GetCellType(-1);
CFont * pOldFont = NULL;
// get the default font if there is one
if( m_GI->m_defFont != NULL )
{
pOldFont = dc.SelectObject( ( CFont* )m_GI->m_defFont );
}
cellType->OnDraw(&dc,&rect,-1,-1,&cell,0,0);
if( m_GI->m_defFont != NULL && pOldFont != NULL )
dc.SelectObject( pOldFont );
}
// v7.2 - update 04 - added as a pared down version of OnPaint to handle
// WM_PRINT message - called from WindowProc below. TD
void CUGCnrBtn::OnPrint(CDC *dc)
{
RECT rect;
GetClientRect(&rect);
CUGCellType * cellType;
CUGCell cell;
m_ctrl->GetCellIndirect(-1,-1,&cell);
//get the cell type to draw the cell
if(cell.IsPropertySet(UGCELL_CELLTYPE_SET))
cellType = m_ctrl->GetCellType(cell.GetCellType());
else
cellType = m_ctrl->GetCellType(-1);
CFont * pOldFont = NULL;
// get the default font if there is one
if( m_GI->m_defFont != NULL )
{
pOldFont = dc->SelectObject( ( CFont* )m_GI->m_defFont );
}
cellType->OnDraw(dc,&rect,-1,-1,&cell,0,0);
if( m_GI->m_defFont != NULL && pOldFont != NULL )
dc->SelectObject( pOldFont );
}
/***************************************************
OnLClicked - overloaded CUGCellType::OnLClicked
Checks to see if the slider has been clicked on.
If the mouse button is pressed over the slider,
then the slider is put into a interactive update
state.
Once the mouse button is release the interactive
update state is turned off
**See CUGCellType::OnLClicked for more details
about this function
****************************************************/
BOOL CUGSliderType::OnLClicked(int col,long row,int updn,RECT *rect,POINT *point){
if(updn)
{
m_updateSlider = FALSE;
}
CUGCell cell;
m_ctrl->GetCell(col,row,&cell);
//get the slider percentage
int percent = 0;
if(cell.IsPropertySet(UGCELL_STRING_SET))
percent = _ttol(cell.GetText());
//get the percent
if(percent >100)
percent = 100;
else if(percent <0)
percent = 0;
//find the slider x position
long width = rect->right - rect->left - 6;
int xPos = rect->left + 3 + ((width * percent) / 100);
int mouseX = point->x;
if(mouseX > xPos- 6 && mouseX < xPos+6)
{
m_updateSlider = TRUE;
return TRUE;
}
return FALSE;
}
/***************************************************
GetJoinRange
function returns join information related to the cell specified
in the col and row parameters. These parameters might be changed
to represent starting col, row position of the join.
Params:
col, row - identify the cell to retrieve join information on,
these parameters will represent the starting pos
of the join.
endCol, - will be set to the end col, row position of the
endRow join.
Returns:
UG_SUCCESS - on success
UG_ERROR - if joins are disabled, or cell specified is not part of a join
*****************************************************/
int CUGTopHdg::GetJoinRange(int *col,int *row,int *endCol,int *endRow)
{
if(m_GI->m_enableJoins == FALSE)
return UG_ERROR;
int startCol;
long startRow, joinRow;
BOOL origin;
CUGCell cell;
m_ctrl->GetCellIndirect(*col,*row,&cell);
if(cell.IsPropertySet(UGCELL_JOIN_SET) == FALSE)
return UG_ERROR;
cell.GetJoinInfo(&origin,&startCol,&startRow);
if(!origin)
{
*col += startCol;
*row += (int)startRow;
m_ctrl->GetCellIndirect(*col,*row,&cell);
}
cell.GetJoinInfo(&origin,endCol,&joinRow);
*endCol +=*col;
*endRow = joinRow + *row;
return UG_SUCCESS;
}
/***************************************************
StartDropList
This internal function is used to parse out
the label string, which contains the items to
show in the list. Also this function will
show the list box in the proper location on the
screen.
Params:
<none>
Return:
UG_ERROR - the list is already visible.
UG_SUCCESS - everything went smoothly, the drop
list was shown
***************************************************/
int CUGDropListType::StartDropList()
{
RECT rect;
RECT clientRect;
int dif,len,pos,startpos;
CFont * font = NULL;
LOGFONT lf;
CFont * cfont;
CStringList list; //lists of strings for the list are assembed here
CString * items; //points to the string used to assemble the list
//return false if it is already up
if( m_listBox->m_HasFocus)
return UG_ERROR;
CUGCell cell;
m_ctrl->GetCellIndirect(m_btnCol,m_btnRow,&cell);
// make sure that the read only cells do not show droplist
if ( cell.GetReadOnly() == TRUE )
return UG_SUCCESS;
//get the current row and col
m_btnCol = m_ctrl->GetCurrentCol();
m_btnRow = m_ctrl->GetCurrentRow();
//add the strings to the CStringList
CString string;
cell.GetLabelText(&string);
items = &string;
len = items->GetLength();
pos =0;
startpos =0;
while(pos <len){
if(items->GetAt(pos)== _T('\n')){
list.AddTail(items->Mid(startpos,pos-startpos));
startpos = pos+1;
}
pos++;
}
//notify the user of the list, so it can be modified if needed
if ( OnCellTypeNotify(m_ID,m_btnCol,m_btnRow,UGCT_DROPLISTSTART,(LONG_PTR)&list) == FALSE )
// if FALSE was returned from OnCellTypeNotify call, than the developer does not
// wish to show the drop list at the moment.
return UG_ERROR;
// set default font height
lf.lfHeight = 12;
//get the font
if(cell.IsPropertySet(UGCELL_FONT_SET))
font = cell.GetFont();
else if(m_ctrl->m_GI->m_defFont != NULL)
font = m_ctrl->m_GI->m_defFont;
if(font == NULL)
font = CFont::FromHandle((HFONT)GetStockObject(SYSTEM_FONT));
if(font != NULL)
{
//find the height of the font
cfont = font;
cfont->GetLogFont(&lf); // lf.lfHeight
if( lf.lfHeight < 0 ){
HDC hDC = CreateCompatibleDC(NULL);
lf.lfHeight = -MulDiv(lf.lfHeight, GetDeviceCaps(hDC, LOGPIXELSY), 72);
DeleteDC(hDC);
}
}
//get the rectangle for the listbox
m_ctrl->GetCellRect(m_btnCol,m_btnRow,&rect);
rect.top = rect.bottom;
rect.left+=10;
rect.right+=10;
len = (int)list.GetCount();
if(len >15)
len = 15;
rect.bottom += lf.lfHeight * len + 6;
m_ctrl->m_CUGGrid->GetClientRect(&clientRect);
if(rect.bottom > clientRect.bottom){
dif = rect.bottom - clientRect.bottom;
rect.bottom -= dif;
rect.top -= dif;
if(rect.top <0)
rect.top = 0;
}
if(rect.right > clientRect.right){
dif = rect.right - clientRect.right;
rect.right -= dif;
rect.left -= dif;
if(rect.left <0)
rect.left = 0;
}
//create the CListBox
m_listBox->m_ctrl = m_ctrl;
m_listBox->m_cellType = this;
m_listBox->m_cellTypeId = m_ID;
m_listBox->Create(WS_CHILD|WS_BORDER|WS_VSCROLL,rect,m_ctrl->m_CUGGrid,123);
//set up the font
if(font != NULL)
m_listBox->SetFont(font);
// v7.2 - update 03 - this works to eliminate blank lines that
// can occur with odd sized fonts/number of items. Fix courtesy Gerbrand
// .start
int itHeight = m_listBox->GetItemHeight(0);
if (len > 15)
len = 15;
rect.bottom = rect.top + len * itHeight + 6;
if(rect.bottom > clientRect.bottom){
dif = rect.bottom - clientRect.bottom;
rect.bottom -= dif;
rect.top -= dif;
if(rect.top <0)
rect.top = 0;
}
// v7.2 - update 03 - Adjust the rect width to accomodate the largest string
// Allen Shiels
dif = GetMaxStringWidth(list) - (rect.right-rect.left);
if (dif > 0) {
if (len >= 15) // add a scroll bar width if max items in list
dif += GetSystemMetrics(SM_CXVSCROLL);
rect.right += dif;
}
if(rect.right > clientRect.right){
dif = rect.right - clientRect.right;
rect.right -= dif;
rect.left -= dif;
if(rect.left <0)
rect.left = 0;
}
// .end
//resize the window again since a new font is being used
m_listBox->MoveWindow(&rect,FALSE);
//add the items to the list
len = (int)list.GetCount();
POSITION position = list.GetHeadPosition();
pos =0;
while(pos < len){
m_listBox->AddString(list.GetAt(position));
pos++;
if(pos < len)
list.GetNext(position);
}
//give the list box pointers to the cell
m_listBox->m_col = &m_btnCol;
m_listBox->m_row = &m_btnRow;
m_listBox->ShowWindow(SW_SHOW);
m_listBox->SetFocus();
m_btnDown = FALSE;
m_ctrl->RedrawCell(m_btnCol,m_btnRow);
return UG_SUCCESS;
}
/***************************************************
DrawCellsIntern
function is the key to the fast redraw functionality in the Ultimate Grid.
This function is responsible for drawing cells within the grid area, it
makes sure that only the cells that are marked as invalid
(by calling CUGDrawHint::IsInvalid function) are redrawn.
Params:
dc - pointer DC to draw on
Returns:
<none>
*****************************************************/
void CUGTopHdg::DrawCellsIntern(CDC *dc)
{
CRect rect(0,0,0,0), cellRect;
CUGCell cell;
CUGCellType * cellType;
int dcID;
int xIndex,col;
long yIndex,row;
m_ctrl->OnScreenDCSetup(dc,NULL,UG_TOPHEADING);
//set the default font
if(m_GI->m_defFont != NULL)
dc->SelectObject((CFont *) m_GI->m_defFont);
int blankRight = 0;
for(yIndex = (m_GI->m_numberTopHdgRows * -1); yIndex < 0 ; yIndex++)
{
row = yIndex;
for(xIndex = 0;xIndex < m_GI->m_numberCols;xIndex++)
{
if(xIndex == m_GI->m_numLockCols)
xIndex = m_GI->m_leftCol;
col = xIndex;
row = yIndex;
//draw if invalid
if(m_drawHint.IsInvalid(col,row) != FALSE)
{
GetCellRect(col,row,&rect);
CopyRect(&cellRect,&rect);
m_ctrl->GetCellIndirect(col,row,&cell);
if(cell.IsPropertySet(UGCELL_JOIN_SET))
{
GetCellRect(col,row,&cellRect);
m_ctrl->GetJoinStartCell(&col,&row,&cell);
if(m_drawHint.IsValid(col,row))
continue;
m_drawHint.SetAsValid(col,row);
}
if(cellRect.left < cellRect.right)
{
cellType = m_ctrl->GetCellType(cell.GetCellType());
dcID = dc->SaveDC();
if(m_swapEndCol >=0 && col == m_swapStartCol)
cellType->OnDraw(dc,&cellRect,col,row,&cell,1,0);
else
cellType->OnDraw(dc,&cellRect,col,row,&cell,0,0);
dc->RestoreDC(dcID);
}
}
if(rect.right > m_GI->m_gridWidth)
break;
}
if(blankRight < rect.right)
blankRight = rect.right;
}
if(blankRight < m_GI->m_gridWidth)
{
rect.top = 0;
rect.bottom = m_GI->m_topHdgHeight;
rect.left = blankRight;
rect.right = m_GI->m_gridWidth;
// fill-in the area that is not covered by cells
CBrush brush( m_ctrl->OnGetDefBackColor( UG_TOPHEADING ));
dc->FillRect( rect, &brush );
}
}