/***************************************************
* Function : CreatePrimitivesForlistTracesScreen
* Parameters : none
* Return : none
* Description : Creates GPL widgets used in screen - listTracesScreen
***************************************************/
void CreatePrimitivesForlistTracesScreen(void)
{
SetLineType(0);
SetLineThickness(0);
SetColor(12678);
SetFont((void*)&Gentium_Plain_0_0_22);
while(!OutTextXY(17,54,(XCHAR*)listTracesScreen_OTE_18text));
}
/***************************************************
* Function : CreatePrimitivesForcurrentlyRecordingScreen
* Parameters : none
* Return : none
* Description : Creates GPL widgets used in screen - currentlyRecordingScreen
***************************************************/
void CreatePrimitivesForcurrentlyRecordingScreen(void)
{
SetLineType(0);
SetLineThickness(0);
SetColor(12678);
SetFont((void*)&Gentium_Plain_0_0_22);
while(!OutTextXY(57,84,(XCHAR*)currentlyRecordingScreen_OTE_4text));
}
/***************************************************
* Function : CreatePrimitivesForhomeScreen
* Parameters : none
* Return : none
* Description : Creates GPL widgets used in screen - homeScreen
***************************************************/
void CreatePrimitivesForhomeScreen(void)
{
SetLineType(0);
SetLineThickness(0);
SetColor(12678);
SetFont((void*)&Gentium_Plain_0_0_22);
while(!OutTextXY(130,127,(XCHAR*)homeScreen_OTE_4text));
}
void OGL2DBase::MajorGridDrawSetup()
{
SetDrawColor(plot2Dbase.defaultPenSet->GetColor(plot2Dbase.plotAnnotation.gridLineDataPen));
SetLine(plot2Dbase.plotAnnotation.majorGridWidth);
SetLineType(plot2Dbase.plotAnnotation.majorGridLineType);
if (plot2Dbase.plotAnnotation.gridOverData)
SetGridHigh();
}
void DrawGridVerticals( void )
{
SHORT x;
SetLineType( DOTTED_LINE );
for (x = GRAPH_GRID_LEFT + GRID_SPACING_HORIZONTAL - graphOffset; x < GRAPH_GRID_RIGHT; x += GRID_SPACING_HORIZONTAL)
{
Line( x, GRAPH_GRID_TOP, x, GRAPH_GRID_BOTTOM );
}
}
void DrawGridHorizontals( void )
{
SHORT y;
SetLineType( DOTTED_LINE );
for (y = GRAPH_GRID_TOP + GRID_SPACING_VERTICAL; y < GRAPH_GRID_BOTTOM; y += GRID_SPACING_VERTICAL)
{
Line( GRAPH_GRID_LEFT, y, GRAPH_GRID_RIGHT, y );
}
}
void IndicateFocus( SHORT lineColor )
{
EDITBOX *currentEditbox;
BUTTON *currentMinus;
currentEditbox = (EDITBOX *)GOLFindObject( CURRENT_EDITBOX );
currentMinus = (BUTTON *) GOLFindObject( CURRENT_MINUS );
SetColor( lineColor );
SetLineType( SOLID_LINE );
Rectangle( currentEditbox->hdr.left-1, currentEditbox->hdr.top-1,
currentMinus->hdr.right+1, currentMinus->hdr.bottom+1 );
}
static WORD DrawOrHideDecoration(void)
{
static int drawState;
OBJ_HEADER *pObj;
SHORT l, t, r, b;
if (showDecoration != showDecorationPrev) {
showDecorationPrev = showDecoration;
drawState = 0;
}
switch (drawState) {
case 0:
// prepare style
SetLineThickness(THICK_LINE);
SetLineType(DASHED_LINE);
if (showDecoration)
SetColor(GFX_SCHEMEDEFAULT.Color1);
else
SetColor(GFX_SCHEMEDEFAULT.CommonBkColor);
drawState++;
/* fall through */
case 1:
// draw/hide decoration
pObj = GOLFindObject(ID_BUTTON);
if (pObj == NULL)
break;
l = pObj->left - 5;
t = pObj->top - 5;
r = pObj->right + 5;
b = pObj->bottom + 5;
if (!Rectangle(l, t, r, b))
return 0;
drawState++;
/* fall through */
default:
break;
}
return 1;
}
void CMenuElementUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcsicmp(pstrName, _T("icon")) == 0){
SetIcon(pstrValue);
}
else if( _tcsicmp(pstrName, _T("iconsize")) == 0 ) {
LPTSTR pstr = NULL;
LONG cx = 0, cy = 0;
cx = _tcstol(pstrValue, &pstr, 10); ASSERT(pstr);
cy = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
SetIconSize(cx, cy);
}
else if( _tcsicmp(pstrName, _T("checkitem")) == 0 ) {
SetCheckItem(_tcsicmp(pstrValue, _T("true")) == 0 ? true : false);
}
else if( _tcsicmp(pstrName, _T("ischeck")) == 0 ) {
if (CMenuWnd::GetGlobalContextMenuObserver().GetMenuCheckInfo() != NULL && CMenuWnd::GetGlobalContextMenuObserver().GetMenuCheckInfo()->find(GetName()) == CMenuWnd::GetGlobalContextMenuObserver().GetMenuCheckInfo()->end())
{
SetChecked(_tcsicmp(pstrValue, _T("true")) == 0 ? true : false);
}
}
else if( _tcsicmp(pstrName, _T("linetype")) == 0){
if (_tcsicmp(pstrValue, _T("true")) == 0)
SetLineType();
}
else if( _tcsicmp(pstrName, _T("expland")) == 0 ) {
SetShowExplandIcon(_tcsicmp(pstrValue, _T("true")) == 0 ? true : false);
}
else if( _tcsicmp(pstrName, _T("linecolor")) == 0){
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
SetLineColor(_tcstoul(pstrValue, &pstr, 16));
}
else if( _tcsicmp(pstrName, _T("linepadding")) == 0 ) {
RECT rcInset = { 0 };
LPTSTR pstr = NULL;
rcInset.left = _tcstol(pstrValue, &pstr, 10); ASSERT(pstr);
rcInset.top = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
rcInset.right = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
rcInset.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
SetLinePadding(rcInset);
}
else if ( _tcsicmp(pstrName, _T("height")) == 0){
SetFixedHeight(_ttoi(pstrValue));
}
else
CListContainerElementUI::SetAttribute(pstrName, pstrValue);
}
/****************************************************************************
Function:
void ShowScreenGraph( void )
Description:
This function erases the currently displayed screen and replaces it with
the graphing demonstration. It draws the initial grid, and initializes
the variables needed for the demo.
Precondition:
None
Parameters:
None
Returns:
None
Remarks:
The global list of graphics objects is destroyed and replaced. Therefore,
this function cannot be called during the message processing of
GOLMsgCallback(). It must be called during GOLDrawCallback() processing.
***************************************************************************/
void ShowScreenGraph( void )
{
// strcpy( pageInformation.title, "Potentiometer Graph" );
// InitializeScreen();
//
// // Create the hidden controls to receive touchpad messages.
//
// BtnCreate( ID_GRAPH_FASTER,
// GetMaxX()-8, 0, GetMaxX()-6, 2, 3,
// BTN_HIDE,
// NULL,
// NULL,
// NULL );
//
// BtnCreate( ID_GRAPH_SLOWER,
// GetMaxX()-6, 0, GetMaxX()-4, 2, 3,
// BTN_HIDE,
// NULL,
// NULL,
// NULL );
//
// BtnCreate( ID_GRAPH_HOME,
// GetMaxX()-4, 0, GetMaxX()-2, 2, 3,
// BTN_HIDE,
// NULL,
// NULL,
// NULL );
GOLPanelDraw( GRAPH_PANEL_LEFT, GRAPH_PANEL_TOP, GRAPH_PANEL_RIGHT, GRAPH_PANEL_BOTTOM, 0,
BLACK, NULL, NULL, NULL, GOL_EMBOSS_SIZE);
GOLPanelDrawTsk(); // draw panel for graph
// Draw the initial grid.
SetColor( WHITE );
SetLineType( DOTTED_LINE );
previousTick = tick;
graphOffset = 0;
graphDataHead = 0;
graphDataTail = 0;
graphUpdateRate = GRAPH_UPDATE_INTERVAL_INIT;
// DrawGridVerticals();
// DrawGridHorizontals();
}
void OGL3DBase::DrawOneAxes( const double& axMin,
const double& axMax,
const SC_DoubleArray& majorIncs,
const SC_DoubleArray& minorIncs,
const PC_AxesFormat& format,
Point2D& stPoint,
Point2D& majTicEndPoint,
Point2D& minTicEndPoint,
Point2D& gridEndPoint,
Point2D& offsetEndPoint,
double& stComponent,
double& majTicComponent,
double& minTicComponent,
double& gridComponent,
double& offsetComponent,
const double& zValue,
Plane3D axPlane,
bool axisIsLog)
{
Point2D* endPoint;
double* endComponent;
PC_3DAxesFormat& axesFormat = plot3Dbase.axesFormat;
DC_PenSet& penSet = *plot3Dbase.defaultPenSet; // default PenSet used for plot
if (format.axesLinePos == PC_AxesFormat::alpBoth)
{
SetDrawColor(penSet.GetColor(axesFormat.axesLinePen));
SetLine(axesFormat.axesLineWidth);
SetLineSolid();
HardCopyBlockStart(6);
stComponent = axMin;
Point2D axSt = stPoint;
stComponent = axMax;
Point2D axEnd = stPoint;
DrawLine(axSt, axEnd, zValue, axPlane);
// needed at axes end to make offsets look clean
endPoint = &offsetEndPoint;
endComponent = &offsetComponent;
stComponent = axMin;
*endComponent = stComponent;
DrawLine(stPoint, *endPoint, zValue, axPlane);
stComponent = axMax;
*endComponent = stComponent;
DrawLine(stPoint, *endPoint, zValue, axPlane);
HardCopyBlockEnd();
}
if ((format.axesMajorInc == PC_Axes::aitGrid) ||
((format.axesMajorInc == PC_Axes::aitTic) && (format.axesTicPos == PC_AxesFormat::atpBoth)))
{
SetDrawColor(penSet.GetColor(axesFormat.majorPen));
if (format.axesMajorInc == PC_Axes::aitTic)
{
SetLine(axesFormat.majorTicWidth);
endPoint = &majTicEndPoint;
endComponent = &majTicComponent;
}
else
{
SetLine(axesFormat.majorGridWidth);
SetLineType(axesFormat.majorGridLineType);
endPoint = &gridEndPoint;
endComponent = &gridComponent;
}
HardCopyBlockStart(majorIncs.Size() * 2);
for (int i = 0; i < majorIncs.Size(); i++)
{
stComponent = majorIncs[i];
if (Limit::WithinOneLimit(axMin, axMax, stComponent))
{
*endComponent = stComponent;
DrawLine(stPoint, *endPoint, zValue, axPlane);
}
}
HardCopyBlockEnd();
}
if ((format.axesMinorInc == PC_Axes::aitGrid) ||
((format.axesMinorInc == PC_Axes::aitTic) && (format.axesTicPos == PC_AxesFormat::atpBoth)))
{
SetDrawColor(penSet.GetColor(axesFormat.minorPen));
if (format.axesMinorInc == PC_Axes::aitTic)
{
SetLine(axesFormat.minorTicWidth);
endPoint = &minTicEndPoint;
endComponent = &minTicComponent;
}
else
{
SetLine(axesFormat.minorGridWidth);
SetLineType(axesFormat.minorGridLineType);
endPoint = &gridEndPoint;
endComponent = &gridComponent;
}
HardCopyBlockStart((majorIncs.Size() + 1) * minorIncs.Size() * 2);
if (!axisIsLog)
{
double multVal = 1.0;
if (axMin > axMax )
multVal = -1.0;
for (int i = -1; i < majorIncs.Size(); i++)
for (int j = 0; j < minorIncs.Size(); j++)
{
if (i < 0)
stComponent = majorIncs[0] - (minorIncs[j] * multVal);
else
stComponent = majorIncs[i] + (minorIncs[j] * multVal);
if (Limit::WithinOneLimit(axMin, axMax, stComponent))
{
*endComponent = stComponent;
DrawLine(stPoint, *endPoint, zValue, axPlane);
}
}
}
else
{
//
static const double logIncVals[] = {0.30103, 0.47712, 0.60206, 0.69897,
0.77815, 0.84510, 0.90309, 0.95424};
if (axMin < axMax)
{
for (int i = -1; i < majorIncs.Size(); i++)
for (int j = 0; j < 8; j++)
{
if (i < 0)
stComponent = majorIncs[0] - 1.0 + logIncVals[j];
else
stComponent = majorIncs[i] + logIncVals[j];
if (Limit::WithinOneLimit(axMin, axMax, stComponent))
{
*endComponent = stComponent;
DrawLine(stPoint, *endPoint, zValue, axPlane);
}
}
}
else
{
for (int i = -1; i < majorIncs.Size(); i++)
for (int j = 0; j < 8; j++)
{
if (i < 0)
stComponent = majorIncs[0] + logIncVals[j];
else
stComponent = majorIncs[i] - 1.0 + logIncVals[j];
if (Limit::WithinOneLimit(axMin, axMax, stComponent))
{
*endComponent = stComponent;
DrawLine(stPoint, *endPoint, zValue, axPlane);
}
}
}
}
HardCopyBlockEnd();
}
}
/*********************************************************************
* Function: WORD DmDraw(void *pObj)
*
* Notes: This is the state machine to display the changing numbers.
*
**********************************************************************/
WORD DmDraw(void *pObj)
{
typedef enum
{
DM_STATE_IDLE,
DM_STATE_FRAME,
DM_STATE_DRAW_FRAME,
DM_STATE_INIT,
DM_STATE_SETALIGN,
DM_STATE_SETTEXT,
DM_STATE_ERASETEXT,
DM_STATE_DRAWTEXT,
DM_STATE_WRAPUP
} DM_DRAW_STATES;
DIGITALMETER *pDm = NULL;
static DM_DRAW_STATES state = DM_STATE_IDLE;
static SHORT charCtr = 0, lineCtr = 0;
static XCHAR CurValue[DM_WIDTH], PreValue[DM_WIDTH];
static SHORT textWidth = 0;
static XCHAR ch = 0, pch = 0;
pDm = (DIGITALMETER *)pObj;
while(1)
{
if(IsDeviceBusy())
return (0);
switch(state)
{
case DM_STATE_DRAW_FRAME:
if(Rectangle(pDm->hdr.left, pDm->hdr.top, pDm->hdr.right, pDm->hdr.bottom) == 0)
return (0);
state = DM_STATE_INIT;
break;
case DM_STATE_IDLE:
SetClip(CLIP_DISABLE);
#ifdef USE_BISTABLE_DISPLAY_GOL_AUTO_REFRESH
GFX_DRIVER_SetupDrawUpdate( pDm->hdr.left,
pDm->hdr.top,
pDm->hdr.right,
pDm->hdr.bottom);
#endif
if(GetState(pDm, DM_HIDE) || GetState(pDm, DM_DRAW))
{
SetColor(pDm->hdr.pGolScheme->CommonBkColor);
if(Bar(pDm->hdr.left, pDm->hdr.top, pDm->hdr.right, pDm->hdr.bottom) == 0)
return (0);
}
// if the draw state was to hide then state is still IDLE STATE so no need to change state
if (GetState(pDm, DM_HIDE))
{
#ifdef USE_BISTABLE_DISPLAY_GOL_AUTO_REFRESH
GFX_DRIVER_CompleteDrawUpdate( pDm->hdr.left,
pDm->hdr.top,
pDm->hdr.right,
pDm->hdr.bottom);
#endif
return (1);
}
state = DM_STATE_FRAME;
case DM_STATE_FRAME:
if(GetState(pDm, DM_DRAW | DM_FRAME) == (DM_DRAW | DM_FRAME))
{
// show frame if specified to be shown
SetLineType(SOLID_LINE);
SetLineThickness(NORMAL_LINE);
if(!GetState(pDm, DM_DISABLED))
{
// show enabled color
SetColor(pDm->hdr.pGolScheme->Color1);
}
else
{
// show disabled color
SetColor(pDm->hdr.pGolScheme->ColorDisabled);
}
state = DM_STATE_DRAW_FRAME;
break;
}
else
{
state = DM_STATE_INIT;
}
case DM_STATE_INIT:
if(IsDeviceBusy())
return (0);
// set clipping area, text will only appear inside the static text area.
SetClip(CLIP_ENABLE);
SetClipRgn(pDm->hdr.left + DM_INDENT, pDm->hdr.top, pDm->hdr.right - DM_INDENT, pDm->hdr.bottom);
// set the text color
if(!GetState(pDm, DM_DISABLED))
{
SetColor(pDm->hdr.pGolScheme->TextColor0);
}
else
{
SetColor(pDm->hdr.pGolScheme->TextColorDisabled);
}
// convert the values to be displayed in string format
NumberToString(pDm->Pvalue, PreValue, pDm->NoOfDigits, pDm->DotPos);
NumberToString(pDm->Cvalue, CurValue, pDm->NoOfDigits, pDm->DotPos);
// use the font specified in the object
SetFont(pDm->hdr.pGolScheme->pFont);
state = DM_STATE_SETALIGN; // go to drawing of text
case DM_STATE_SETALIGN:
if(!charCtr)
{
// set position of the next character (based on alignment and next character)
textWidth = GetTextWidth(CurValue, pDm->hdr.pGolScheme->pFont);
// Display text with center alignment
if(GetState(pDm, (DM_CENTER_ALIGN)))
{
MoveTo((pDm->hdr.left + pDm->hdr.right - textWidth) >> 1, pDm->hdr.top + (lineCtr * pDm->textHeight));
}
// Display text with right alignment
else if(GetState(pDm, (DM_RIGHT_ALIGN)))
{
MoveTo((pDm->hdr.right - textWidth - DM_INDENT), pDm->hdr.top + (lineCtr * pDm->textHeight));
}
// Display text with left alignment
else
{
MoveTo(pDm->hdr.left + DM_INDENT, pDm->hdr.top + (lineCtr * pDm->textHeight));
}
}
/*********************************************************************
* Function: WORD BtnDraw(BUTTON *pB)
*
*
* Notes: This is the state machine to draw the button.
*
********************************************************************/
WORD BtnDraw(BUTTON *pB)
{
typedef enum {
REMOVE,
BEVEL_DRAW,
RNDBUTTON_DRAW,
TEXT_DRAW,
TEXT_DRAW_RUN,
FOCUS_DRAW,
} BTN_DRAW_STATES;
static BTN_DRAW_STATES state = REMOVE;
static SHORT width, height, radius;
WORD faceClr, embossLtClr, embossDkClr, xText, yText;
if(IsDeviceBusy())
return 0;
switch(state){
case REMOVE:
if(IsDeviceBusy())
return 0;
if (GetState(pB,BTN_HIDE)) { // Hide the button (remove from screen)
SetColor(pB->hdr.pGolScheme->CommonBkColor);
Bar(pB->hdr.left, pB->hdr.top, pB->hdr.right, pB->hdr.bottom);
return 1;
}
/* Note: that width and height adjustment considers the following assumptions:
1. if circular width = height = radius*2
2. if vertical capsule width = radius*2
3. if horizontal capsule height = radius*2
4. radius must be less than or equal to width if height is greater than width
5. radius must be less than or equal to height if width is greater than height
6. if button is cornered, radius must be zero
*/
radius = pB->radius; // get radius
width = (pB->hdr.right - pB->hdr.left) - (radius*2); // get width
height = (pB->hdr.bottom - pB->hdr.top) - (radius*2); // get height
state = BEVEL_DRAW;
case BEVEL_DRAW:
if(!GetState(pB,BTN_DISABLED)){
if(GetState(pB,BTN_PRESSED)){
embossDkClr = pB->hdr.pGolScheme->EmbossLtColor;
embossLtClr = pB->hdr.pGolScheme->EmbossDkColor;
faceClr = pB->hdr.pGolScheme->Color1;
} else {
embossLtClr = pB->hdr.pGolScheme->EmbossLtColor;
embossDkClr = pB->hdr.pGolScheme->EmbossDkColor;
faceClr = pB->hdr.pGolScheme->Color0;
}
}else{
embossLtClr = pB->hdr.pGolScheme->EmbossLtColor;
embossDkClr = pB->hdr.pGolScheme->EmbossDkColor;
faceClr = pB->hdr.pGolScheme->ColorDisabled;
}
SetLineThickness(NORMAL_LINE);
SetLineType(SOLID_LINE);
GOLPanelDraw(pB->hdr.left+radius, pB->hdr.top+radius, pB->hdr.right-radius,
pB->hdr.bottom-radius, radius, faceClr, embossLtClr, embossDkClr,
pB->pBitmap, GOL_EMBOSS_SIZE);
state = RNDBUTTON_DRAW;
case RNDBUTTON_DRAW:
if(!GOLPanelDrawTsk()){
return 0;
}
state = TEXT_DRAW;
case TEXT_DRAW:
if (pB->pText != NULL){
if (!GetState(pB,BTN_DISABLED)){
if (GetState(pB,BTN_PRESSED)){
SetColor(pB->hdr.pGolScheme->TextColor1);
}else{
SetColor(pB->hdr.pGolScheme->TextColor0);
}
}
else{
SetColor(pB->hdr.pGolScheme->TextColorDisabled);
}
SetFont(pB->hdr.pGolScheme->pFont);
// check text alignment
if (GetState(pB, BTN_TEXTRIGHT))
xText = pB->hdr.right-(pB->textWidth+GOL_EMBOSS_SIZE+2);
else if (GetState(pB, BTN_TEXTLEFT))
xText = pB->hdr.left+GOL_EMBOSS_SIZE+2;
else
xText = (pB->hdr.left+pB->hdr.right-pB->textWidth)>>1;
if (GetState(pB, BTN_TEXTTOP))
yText = pB->hdr.top+GOL_EMBOSS_SIZE+2;
else if (GetState(pB, BTN_TEXTBOTTOM))
yText = pB->hdr.bottom-(pB->textHeight+GOL_EMBOSS_SIZE);
else
yText = (pB->hdr.bottom+pB->hdr.top-pB->textHeight)>>1;
MoveTo(xText, yText);
state = TEXT_DRAW_RUN;
}else {
state = FOCUS_DRAW;
goto rnd_button_draw_focus;
}
case TEXT_DRAW_RUN:
if(!OutText(pB->pText))
return 0;
state = FOCUS_DRAW;
case FOCUS_DRAW:
rnd_button_draw_focus:
if(IsDeviceBusy())
return 0;
if(GetState(pB,BTN_FOCUSED)){
SetLineType(FOCUS_LINE);
if(GetState(pB,BTN_PRESSED)) {
SetColor(pB->hdr.pGolScheme->TextColor1);
} else {
SetColor(pB->hdr.pGolScheme->TextColor0);
}
// check if the object has rounded corners or not
if (!pB->radius) {
Rectangle( pB->hdr.left+GOL_EMBOSS_SIZE+2 , pB->hdr.top+GOL_EMBOSS_SIZE+2,
pB->hdr.right-GOL_EMBOSS_SIZE-2, pB->hdr.bottom-GOL_EMBOSS_SIZE-2);
}
else {
// original center is still the same, but radius is reduced
Bevel( pB->hdr.left+radius, pB->hdr.top+radius, \
pB->hdr.right-radius, pB->hdr.bottom-radius, \
radius - 2 - GOL_EMBOSS_SIZE);
}
SetLineType(SOLID_LINE);
}
state = REMOVE;
return 1;
}
/*********************************************************************
* Function: WORD AcDraw(ANALOGCLOCK *pAc)
*
*
* Notes: This is the state machine to draw the clock.
*
********************************************************************/
WORD AcDraw(void *pObj)
{
typedef enum
{
REMOVE,
BEVEL_DRAW,
TICK
} AC_DRAW_STATES;
static AC_DRAW_STATES state = REMOVE;
static SHORT width, height, radius;
static GFX_COLOR faceClr, handClr;
ANALOGCLOCK *pAc;
pAc = (ANALOGCLOCK *)pObj;
if(IsDeviceBusy())
return (0);
switch(state)
{
case REMOVE:
if(IsDeviceBusy())
return (0);
if(GetState(pAc, AC_HIDE)) // Hide the button (remove from screen)
{
SetColor(pAc->hdr.pGolScheme->CommonBkColor);
if(!Bar(pAc->hdr.left, pAc->hdr.top, pAc->hdr.right, pAc->hdr.bottom))
{
return (0);
}
}
if(GetState(pAc, AC_TICK))
{
state = TICK;
return(1); //buthave to do goto erase
//goto erase_current_pos;
}
if(GetState(pAc, UPDATE_HOUR))
{
AcHandsDraw(pAc, HOUR, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
state = TICK;
return(1); //buthave to do goto erase
//goto erase_current_pos;
}
if(GetState(pAc, UPDATE_MINUTE))
{
AcHandsDraw(pAc, MINUTE, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
state = TICK;
return(1); //buthave to do goto erase
//goto erase_current_pos;
}
if(GetState(pAc, UPDATE_SECOND))
{
AcHandsDraw(pAc, SECOND, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
state = TICK;
return(1); //buthave to do goto erase
//goto erase_current_pos;
}
radius = pAc->radius; // get radius
width = (pAc->hdr.right - pAc->hdr.left) - (radius * 2); // get width
height = (pAc->hdr.bottom - pAc->hdr.top) - (radius * 2); // get height
state = BEVEL_DRAW;
case BEVEL_DRAW:
faceClr = pAc->hdr.pGolScheme->Color0;
handClr = pAc->hdr.pGolScheme->Color1;
SetLineThickness(NORMAL_LINE);
SetLineType(SOLID_LINE);
SetColor(faceClr);
FillCircle(pAc->centerx,pAc->centery, radius); //Draw Face of Analog Clock
SetColor(handClr);
FillCircle(pAc->centerx,pAc->centery, 8); //Draw Middle of Analog Clock
AcHandsDraw(pAc, SECOND, THICKNESS_SECOND, handClr, pAc->pBitmap);
AcHandsDraw(pAc, HOUR, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
AcHandsDraw(pAc, MINUTE, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
state = REMOVE;
break;
case TICK:
AcHandsDraw(pAc, SECOND, THICKNESS_SECOND, handClr, pAc->pBitmap);
if(pAc->valueS++ == 60)
{
pAc->valueS = 1;
if(pAc->valueM++ == 60)
{
pAc->valueM = 1;
}
if(pAc->valueM%12 == 0)
{
pAc->valueH++;
if(pAc->valueH == 60)
pAc->valueH = 0;
AcHandsDraw(pAc, HOUR, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
}
AcHandsDraw(pAc, MINUTE, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
}
if( ((pAc->valueS - pAc->valueM)<4 && (pAc->valueS - pAc->valueM)>=0) || ((pAc->valueS - pAc->valueM)<-56 && (pAc->valueS - pAc->valueM)>-59) )
AcHandsDraw(pAc, MINUTE, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
if( ((pAc->valueS - pAc->valueH)<4 && (pAc->valueS - pAc->valueH)>=0) || ((pAc->valueS - pAc->valueH)<-56 && (pAc->valueS - pAc->valueH)>-59) )
AcHandsDraw(pAc, HOUR, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
if(pAc->valueS-1 == pAc->valueM)
AcHandsDraw(pAc, MINUTE, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
if(pAc->valueS-1 == pAc->valueH)
AcHandsDraw(pAc, HOUR, THICKNESS_SECOND+4, handClr, pAc->pBitmap);
state = REMOVE;
return (1);
}
return (1);
}
/*********************************************************************
* Function: WORD PictDraw(PICTURE *pPict)
*
* Output: returns the status of the drawing
* 0 - not completed
* 1 - done
*
* Overview: draws picture
*
********************************************************************/
WORD PictDraw(PICTURE *pPict)
{
typedef enum
{
REMOVE,
DRAW_IMAGE,
DRAW_BACKGROUND1,
DRAW_BACKGROUND2,
DRAW_BACKGROUND3,
DRAW_BACKGROUND4,
DRAW_FRAME
} PICT_DRAW_STATES;
static PICT_DRAW_STATES state = REMOVE;
static SHORT posleft;
static SHORT postop;
static SHORT posright;
static SHORT posbottom;
if(IsDeviceBusy())
return (0);
switch(state)
{
case REMOVE:
if(GetState(pPict, PICT_HIDE))
{
SetColor(pPict->hdr.pGolScheme->CommonBkColor);
if(!Bar(pPict->hdr.left, pPict->hdr.top, pPict->hdr.right, pPict->hdr.bottom))
return (0);
return (1);
}
posleft = (pPict->hdr.left + pPict->hdr.right - pPict->scale * GetImageWidth(pPict->pBitmap)) >> 1;
postop = (pPict->hdr.top + pPict->hdr.bottom - pPict->scale * GetImageHeight(pPict->pBitmap)) >> 1;
posright = (pPict->hdr.right + pPict->hdr.left + pPict->scale * GetImageWidth(pPict->pBitmap)) >> 1;
posbottom = (pPict->hdr.bottom + pPict->hdr.top + pPict->scale * GetImageHeight(pPict->pBitmap)) >> 1;
state = DRAW_IMAGE;
case DRAW_IMAGE:
if(pPict->pBitmap != NULL)
{
if(IsDeviceBusy())
return (0);
if(!PutImage(posleft, postop, pPict->pBitmap, pPict->scale))
return (0);
}
SetColor(pPict->hdr.pGolScheme->CommonBkColor);
state = DRAW_BACKGROUND1;
case DRAW_BACKGROUND1:
if(!Bar(pPict->hdr.left + 1, pPict->hdr.top + 1, pPict->hdr.right - 1, postop - 1))
return (0);
state = DRAW_BACKGROUND2;
case DRAW_BACKGROUND2:
if(!Bar(pPict->hdr.left + 1, posbottom, pPict->hdr.right - 1, pPict->hdr.bottom - 1))
return (0);
state = DRAW_BACKGROUND3;
case DRAW_BACKGROUND3:
if(!Bar(pPict->hdr.left + 1, postop, posleft - 1, posbottom))
return (0);
state = DRAW_BACKGROUND4;
case DRAW_BACKGROUND4:
if(!Bar(posright, postop, pPict->hdr.right - 1, posbottom))
return (0);
state = DRAW_FRAME;
case DRAW_FRAME:
if(GetState(pPict, PICT_FRAME))
{
SetLineType(SOLID_LINE);
SetColor(pPict->hdr.pGolScheme->TextColor0);
if(!Rectangle(pPict->hdr.left, pPict->hdr.top, pPict->hdr.right, pPict->hdr.bottom))
return (0);
}
state = REMOVE;
return (1);
}
return (1);
}
/*********************************************************************
* Function: WORD StDraw(STATICTEXT *pSt)
*
* Notes: This is the state machine to draw the static text.
*
********************************************************************/
WORD StDraw(STATICTEXT *pSt)
{
typedef enum {
ST_STATE_IDLE,
ST_STATE_CLEANAREA,
ST_STATE_INIT,
ST_STATE_SETALIGN,
ST_STATE_DRAWTEXT
} ST_DRAW_STATES;
static ST_DRAW_STATES state = ST_STATE_IDLE;
static SHORT charCtr = 0, lineCtr = 0;
static XCHAR *pCurLine = NULL;
SHORT textWidth;
XCHAR ch = 0;
if(IsDeviceBusy())
return 0;
switch(state){
case ST_STATE_IDLE:
SetClip(CLIP_DISABLE);
if (GetState(pSt, ST_HIDE)) {
SetColor(pSt->hdr.pGolScheme->CommonBkColor);
if(!Bar(pSt->hdr.left,pSt->hdr.top,pSt->hdr.right,pSt->hdr.bottom))
return 0;
// State is still IDLE STATE so no need to set
return 1;
}
if (GetState(pSt, ST_DRAW)) {
if (GetState(pSt, ST_FRAME)) {
// show frame if specified to be shown
SetLineType(SOLID_LINE);
SetLineThickness(NORMAL_LINE);
if(!GetState(pSt,ST_DISABLED)){
// show enabled color
SetColor(pSt->hdr.pGolScheme->Color1);
if(!Rectangle(pSt->hdr.left,pSt->hdr.top,pSt->hdr.right,pSt->hdr.bottom))
return 0;
}
else {
// show disabled color
SetColor(pSt->hdr.pGolScheme->ColorDisabled);
if(!Rectangle(pSt->hdr.left,pSt->hdr.top,pSt->hdr.right,pSt->hdr.bottom))
return 0;
}
}
}
// set clipping area, text will only appear inside the static text area.
SetClip(CLIP_ENABLE);
SetClipRgn(pSt->hdr.left+ST_INDENT, pSt->hdr.top, \
pSt->hdr.right-ST_INDENT, pSt->hdr.bottom);
state = ST_STATE_CLEANAREA;
case ST_STATE_CLEANAREA:
// clean area where text will be placed.
SetColor(pSt->hdr.pGolScheme->CommonBkColor);
if(!Bar(pSt->hdr.left+1,pSt->hdr.top + 1,pSt->hdr.right-1,pSt->hdr.bottom-1))
return 0;
state = ST_STATE_INIT;
case ST_STATE_INIT:
if(IsDeviceBusy())
return 0;
// set the text color
if(!GetState(pSt,ST_DISABLED)){
SetColor(pSt->hdr.pGolScheme->TextColor0);
}
else {
SetColor(pSt->hdr.pGolScheme->TextColorDisabled);
}
// use the font specified in the object
SetFont(pSt->hdr.pGolScheme->pFont);
pCurLine = pSt->pText; // get first line of text
state = ST_STATE_SETALIGN; // go to drawing of text
case ST_STATE_SETALIGN:
st_state_alignment:
if (!charCtr) {
// set position of the next character (based on alignment and next character)
textWidth = GetTextWidth(pCurLine, pSt->hdr.pGolScheme->pFont);
// Display text with center alignment
if (GetState(pSt, (ST_CENTER_ALIGN))) {
MoveTo((pSt->hdr.left+pSt->hdr.right-textWidth) >> 1, \
pSt->hdr.top+(lineCtr * pSt->textHeight));
}
// Display text with right alignment
/*********************************************************************
* Function: WORD CbDraw(CHECKBOX *pCb)
*
* Output: returns the status of the drawing
* 0 - not complete
* 1 - done
*
* Overview: Draws check box.
*
********************************************************************/
WORD CbDraw(CHECKBOX *pCb)
{
typedef enum {
REMOVE,
BOX_DRAW,
RUN_DRAW,
TEXT_DRAW,
TEXT_DRAW_RUN,
CHECK_DRAW,
FOCUS_DRAW
} CB_DRAW_STATES;
static CB_DRAW_STATES state = REMOVE;
SHORT checkIndent;
if(IsDeviceBusy())
return 0;
switch(state) {
case REMOVE:
if(GetState(pCb,CB_HIDE|CB_DRAW)) {
if(IsDeviceBusy())
return 0;
SetColor(pCb->hdr.pGolScheme->CommonBkColor);
Bar(pCb->hdr.left,pCb->hdr.top,pCb->hdr.right,pCb->hdr.bottom);
if(GetState(pCb,CB_HIDE))
return 1;
}
state = BOX_DRAW;
case BOX_DRAW:
if(GetState(pCb,CB_DRAW)) {
if(!GetState(pCb,CB_DISABLED)) {
GOLPanelDraw(pCb->hdr.left+CB_INDENT,pCb->hdr.top+CB_INDENT,
pCb->hdr.left+(pCb->hdr.bottom-pCb->hdr.top)-CB_INDENT,
pCb->hdr.bottom-CB_INDENT, 0,
pCb->hdr.pGolScheme->Color0,
pCb->hdr.pGolScheme->EmbossDkColor,
pCb->hdr.pGolScheme->EmbossLtColor,
NULL, GOL_EMBOSS_SIZE);
} else {
GOLPanelDraw(pCb->hdr.left+CB_INDENT,pCb->hdr.top+CB_INDENT,
pCb->hdr.left+(pCb->hdr.bottom-pCb->hdr.top)-CB_INDENT,
pCb->hdr.bottom-CB_INDENT, 0,
pCb->hdr.pGolScheme->ColorDisabled,
pCb->hdr.pGolScheme->EmbossDkColor,
pCb->hdr.pGolScheme->EmbossLtColor,
NULL, GOL_EMBOSS_SIZE);
}
state = RUN_DRAW;
case RUN_DRAW:
if(!GOLPanelDrawTsk())
return 0;
state = TEXT_DRAW;
case TEXT_DRAW:
if(pCb->pText != NULL) {
SetFont(pCb->hdr.pGolScheme->pFont);
if (!GetState(pCb,CB_DISABLED)) {
SetColor(pCb->hdr.pGolScheme->TextColor0);
} else {
SetColor(pCb->hdr.pGolScheme->TextColorDisabled);
}
MoveTo(pCb->hdr.left+pCb->hdr.bottom-pCb->hdr.top+CB_INDENT,
(pCb->hdr.bottom+pCb->hdr.top-pCb->textHeight)>>1);
state = TEXT_DRAW_RUN;
case TEXT_DRAW_RUN:
if(!OutText(pCb->pText))
return 0;
}
}
state = CHECK_DRAW;
case CHECK_DRAW:
if(GetState(pCb,CB_DRAW|CB_DRAW_CHECK)) {
if(IsDeviceBusy())
return 0;
if(!GetState(pCb,CB_DISABLED)) {
if(GetState(pCb,CB_CHECKED)) {
SetColor(pCb->hdr.pGolScheme->TextColor0);
} else {
SetColor(pCb->hdr.pGolScheme->Color0);
}
} else {
if(GetState(pCb,CB_CHECKED)) {
SetColor(pCb->hdr.pGolScheme->TextColorDisabled);
} else {
SetColor(pCb->hdr.pGolScheme->ColorDisabled);
}
}
checkIndent = (pCb->hdr.bottom-pCb->hdr.top)>>2;
Bar(pCb->hdr.left+checkIndent+GOL_EMBOSS_SIZE,
pCb->hdr.top+checkIndent+GOL_EMBOSS_SIZE,
pCb->hdr.left+(pCb->hdr.bottom-pCb->hdr.top)-checkIndent-GOL_EMBOSS_SIZE,
pCb->hdr.bottom-checkIndent-GOL_EMBOSS_SIZE);
}
state = FOCUS_DRAW;
case FOCUS_DRAW:
if(GetState(pCb,CB_DRAW|CB_DRAW_FOCUS)) {
if(IsDeviceBusy())
return 0;
if(GetState(pCb,CB_FOCUSED)) {
SetColor(pCb->hdr.pGolScheme->TextColor0);
} else {
SetColor(pCb->hdr.pGolScheme->CommonBkColor);
}
SetLineType(FOCUS_LINE);
Rectangle(pCb->hdr.left, pCb->hdr.top,
pCb->hdr.right, pCb->hdr.bottom);
SetLineType(SOLID_LINE);
}
state = REMOVE;
return 1;
}
WORD GridDraw( GRID *pGrid )
{
SHORT i;
SHORT j;
if ((pGrid->hdr.state & GRID_DRAW_ITEMS) || (pGrid->hdr.state & GRID_DRAW_ALL) || (pGrid->hdr.state & GRID_SHOW_FOCUS))
{
if (pGrid->hdr.state & GRID_DRAW_ALL)
{
// Clear the entire region.
SetColor( pGrid->hdr.pGolScheme->CommonBkColor );
Bar( pGrid->hdr.left, pGrid->hdr.top, pGrid->hdr.right, pGrid->hdr.bottom );
// Draw the grid lines
if (pGrid->hdr.state & (GRID_SHOW_LINES | GRID_SHOW_BORDER_ONLY | GRID_SHOW_SEPARATORS_ONLY))
{
SetLineType( SOLID_LINE );
SetColor( pGrid->hdr.pGolScheme->EmbossLtColor );
// Draw the outside of the box
// TODO This should have some 3D effects added with GOL_EMBOSS_SIZE
if (pGrid->hdr.state & (GRID_SHOW_LINES | GRID_SHOW_BORDER_ONLY))
{
Line( pGrid->hdr.left, pGrid->hdr.top, pGrid->hdr.right, pGrid->hdr.top );
LineTo( _cursorX, pGrid->hdr.bottom );
LineTo( pGrid->hdr.left, _cursorY );
LineTo( pGrid->hdr.left, pGrid->hdr.top );
}
// Draw the lines between each cell
if (pGrid->hdr.state & (GRID_SHOW_LINES | GRID_SHOW_SEPARATORS_ONLY))
{
for (i=1; i< pGrid->numColumns; i++)
{
Line( pGrid->hdr.left + i * (pGrid->cellWidth+1), pGrid->hdr.top,
pGrid->hdr.left + i * (pGrid->cellWidth+1), pGrid->hdr.top + pGrid->numRows * (pGrid->cellHeight+1) );
}
for (i=1; i<pGrid->numRows; i++)
{
Line( pGrid->hdr.left, pGrid->hdr.top + i * (pGrid->cellHeight+1),
pGrid->hdr.right, pGrid->hdr.top + i * (pGrid->cellHeight+1) );
}
}
}
}
for (i = 0; i < pGrid->numColumns; i++)
{
for (j = 0; j < pGrid->numRows; j++)
{
if ((pGrid->hdr.state & GRID_DRAW_ALL) ||
((pGrid->hdr.state & GRID_DRAW_ITEMS) && (pGrid->gridObjects[CELL_AT(i,j)].status & GRIDITEM_DRAW)) ||
((pGrid->hdr.state & GRID_SHOW_FOCUS) && (i == pGrid->focusX) && (j == pGrid->focusY)))
{
// Clear the cell
SetColor( pGrid->hdr.pGolScheme->CommonBkColor );
Bar( CELL_LEFT, CELL_TOP, CELL_RIGHT, CELL_BOTTOM );
// Draw the cell
if ((pGrid->gridObjects[CELL_AT(i,j)].status & GRID_TYPE_MASK) == GRIDITEM_IS_BITMAP)
{
// Draw the bitmap
if (pGrid->gridObjects[CELL_AT(i,j)].data)
{
PutImage( CELL_LEFT, CELL_TOP, pGrid->gridObjects[CELL_AT(i,j)].data, BITMAP_SCALE );
}
}
else
{
// Draw the text
}
// Draw the focus if applicable.
if ((pGrid->hdr.state & GRID_SHOW_FOCUS) && (i == pGrid->focusX) && (j == pGrid->focusY))
{
SetColor( pGrid->hdr.pGolScheme->EmbossLtColor );
SetLineType( DOTTED_LINE );
SetLineThickness( NORMAL_LINE );
Rectangle( CELL_LEFT, CELL_TOP, CELL_RIGHT, CELL_BOTTOM );
}
// If the cell is selected, indicate it.
if (pGrid->gridObjects[CELL_AT(pGrid->focusX,pGrid->focusY)].status & GRIDITEM_SELECTED)
{
SetColor( pGrid->hdr.pGolScheme->EmbossLtColor );
SetLineType( SOLID_LINE );
if (pGrid->hdr.state & GRID_SHOW_LINES)
{
SetLineThickness( THICK_LINE );
}
else
{
SetLineThickness( NORMAL_LINE );
}
Rectangle( CELL_LEFT-1, CELL_TOP-1, CELL_RIGHT+1, CELL_BOTTOM+1 );
}
GridClearCellState( pGrid, i, j, GRIDITEM_DRAW );
}
}
}
//pGrid->state &= ~(GRID_DRAW_ITEMS || GRID_DRAW_ALL || GRID_SHOW_FOCUS);
pGrid->hdr.state &= ~(GRID_DRAW_ITEMS || GRID_DRAW_ALL );
// Set line state
SetLineType( SOLID_LINE );
}
return 1;
}
//---------------------------------------------------------------------------
void __fastcall TCross::UpdateAngle(void) {
int i, j, k, m = -1;
double a = 90;
int SwitchType = 0;
CrossAngleList AngleList; //转辙角列表
TSwitchList SwitchList;
TCrossLine CL;
int BranchLineNumber = -1;
MainLineNumber = -1;
eBranchSide BranchSide;
for (i = 0; i < Lines.size(); i++) { // 拆分lpMIDDLE的线段
if (Lines[i].Pos == lpMIDDLE) {
CL = Lines[i];
Lines[i].EndX = X;
Lines[i].EndY = Y;
Lines[i].Pos = lpEND;
Lines[i].EndSign = true;
CL.StartX = X;
CL.StartY = Y;
CL.Pos = lpSTART;
CL.StartSign = true;
Lines.push_back(CL); //拆分后的线段没有lpMIDDLE的，因而不必再检查。
}
}
for (i = 0; i < Lines.size(); i++) { // 设置各线段的角度。
if (InRange(X, Y, Lines[i].EndX, Lines[i].EndY, 1)) {
Lines[i].Angle = OppositeAngle(Lines[i].StartAngle);
} else {
Lines[i].Angle = Lines[i].StartAngle;
}
}
sort(Lines.begin(), Lines.end()); // 删除重复线段。
Lines.erase(unique(Lines.begin(), Lines.end()), Lines.end());
MaxAngle = MinAngle = GetAngle(Lines[0].Angle, Lines[1].Angle); //查找最大、最小角度，同时查找与其他线段夹角大于90°的线段，并设置为ltMAIN
MaxAngleA = MaxAngleB = MinAngleA = MinAngleB = -1;
for (i = 0; i < Lines.size(); i++) {
k = 0;
for (j = 0; j < Lines.size(); j++) {
if (i == j)
continue;
a = GetAngle(Lines[i].Angle, Lines[j].Angle);
if (a > 90) {
k++;
}
if (a > MaxAngle) {
MaxAngle = a;
MaxAngleA = i;
MaxAngleB = j;
}
if (a < MinAngle) {
MinAngle = a;
MinAngleA = i;
MinAngleB = j;
}
}
if (k > 1) {
MainLineNumber = i;
}
}
for (i = 0; i < Lines.size(); i++) {
Lines[i].Type = GetBranchSide(Lines[MainLineNumber].Angle, Lines[i].Angle);
SwitchType += Lines[i].Type;
SetLineType(Lines[i].Type, i);
}
FrogNumber = -1; //根据最小角查找对应的辙岔号。
for (i = 0; i < AngleList.size(); i++) {
if (EqualAngle(MinAngle, AngleList[i].Angle)) {
FrogNumber = AngleList[i].FrogNumber;
break;
}
}
if (FrogNumber == -1) {
Type = sNone;
return;
}
switch (SwitchType) { // 确定道岔型号
case 7: // 左单开
switch (FrogNumber) {
case 6:
Type = sSimpleLeft6;
break;
case 9:
Type = sSimpleLeft9;
break;
case 7:
Type = sSimpleLeft7;
break;
default:
Type = sNone;
}
break;
case 11: // 对称
switch (FrogNumber) {
case 6:
Type = sSymmetry6;
break;
case 65:
Type = sSymmetry65;
break;
case 9:
Type = sSymmetry9;
break;
default:
Type = sNone;
}
break;
case 13: //右单开
switch (FrogNumber) {
case 6:
Type = sSimpleRight6;
break;
case 9:
Type = sSimpleRight9;
break;
case 7:
Type = sSimpleRight7;
break;
default:
Type = sNone;
}
break;
case 15: //三开对称
if (FrogNumber == 7)
Type = sTreble7;
else
Type = sNone;
break;
default:
Type = sNone;
}
return;
}
