//-----------------------------------------------------------------------------
//!
//-----------------------------------------------------------------------------
void tWindPlotGraph::OnTimePlotDataUpdated(TimePlot::eTimePlotRange timePlotRange)
{
if(timePlotRange == m_TimePlotRange)
{
UpdateGraph();
}
}
bool FilterMutualInfoPlugin::AlignGlobal(MeshDocument &md, std::vector<SubGraph> graphs)
{
for (int j=0; j<1; j++)
{
for (int i=0; i<graphs.size(); i++)
{
int n=0;
while (!allActive(graphs[i]))
{
//Log(0, "Round %d of %d: get the right node",n+1,graphs[i].nodes.size());
int curr= getTheRightNode(graphs[i]);
graphs[i].nodes[curr].active=true;
//Log(0, "Round %d of %d: align the node",n+1,graphs[i].nodes.size());
AlignNode(md, graphs[i].nodes[curr]);
//Log(0, "Round %d of %d: update the graph",n+1,graphs[i].nodes.size());
UpdateGraph(md, graphs[i], curr);
//Log(0, "Image %d completed",curr);
n++;
}
for (int l=0; l<graphs[i].nodes.size(); l++)
{
graphs[i].nodes[l].active=false;
}
}
}
return true;
}
void GraphWindow::Display(Graph* G)
{
sem_wait(&GUpdateSemaphore);
DisplayedGraph = G;
sem_post(&GUpdateSemaphore);
UpdateGraph();
}
void CChooseApertureDlg::OnSelectionChanged(GtkTreeSelection *selection)
{
int index, ch;
char buf[64];
GtkTreeModel *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
if (model == GTK_TREE_MODEL(m_Apertures) && m_GraphData) {
gtk_tree_model_get(model, &iter, 0, &index, -1);
if (index!=m_ApertureIndex) {
if (m_Row>=0) {
cmpack_graph_data_set_tag(m_GraphData, m_Row, NULL);
cmpack_graph_data_set_color(m_GraphData, m_Row, CMPACK_COLOR_DEFAULT);
cmpack_graph_data_set_topmost(m_GraphData, m_Row, FALSE);
}
m_ApertureIndex = index;
m_Row = cmpack_graph_data_find_item(m_GraphData, m_Aper.GetId(m_ApertureIndex));
if (m_Row>=0) {
sprintf(buf, "Aperture #%d", m_Aper.GetId(m_ApertureIndex));
cmpack_graph_data_set_tag(m_GraphData, m_Row, buf);
cmpack_graph_data_set_color(m_GraphData, m_Row, CMPACK_COLOR_RED);
cmpack_graph_data_set_topmost(m_GraphData, m_Row, TRUE);
}
}
} else
if (model == GTK_TREE_MODEL(m_Channels)) {
gtk_tree_model_get(model, &iter, 0, &ch, -1);
if (ch!=m_Column) {
m_Column = ch;
UpdateGraph(FALSE, TRUE);
}
}
}
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::FormResize(TObject *Sender)
{
Image->Picture->Bitmap->Width = 0;
Image->Picture->Bitmap->Height = 0;
Image->Picture->Bitmap->Width = Image->Width;
Image->Picture->Bitmap->Height = Image->Height;
UpdateGraph ();
}
void CFlatEditEq::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags )
{
switch(nChar)
{
case VK_RETURN: UpdateGraph(); break;
}
CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
}
void QUADAPULT_Update(float dt)
{
if (s_useGraph)
{
UpdateGraph();
}
else
{
sort(s_spriteVec.begin(), s_spriteVec.end(), SpriteCompare);
}
}
// Write graph rectangle to display
void AppWindow::UpdateGraphRect(const BRect graphRect) {
char string[255];
sprintf(string, "%g", graphRect.top);
data->gCtrls[TOP]->SetText(string);
sprintf(string, "%g", graphRect.bottom);
data->gCtrls[BOTTOM]->SetText(string);
sprintf(string, "%g", graphRect.left);
data->gCtrls[LEFT]->SetText(string);
sprintf(string, "%g", graphRect.right);
data->gCtrls[RIGHT]->SetText(string);
UpdateGraph();
}
void CThermoMeterItem::initVariables()
{
m_markClr=Qt::white;
graphcolor=Qt::darkGreen;
m_value=0;
m_currentValue=0;
m_bucketWidth=boundingRect().width()/3;
m_markSpace=(qreal)boundingRect().width()/4;
m_topSpace=(qreal)boundingRect().height()/15;
updateTimer=new QTimer(this);
updateTimer->setInterval(10);
connect(updateTimer,SIGNAL(timeout()),this,SLOT(UpdateGraph()));
m_bReverse=false;
}
void CFlatEditEq::OnKillFocus(CWnd* pNewWnd)
{
CFlatEdit::OnKillFocus(pNewWnd);
CString strEq;
GetWindowText(strEq);
if(strEq != "" && !g_Calculator->IsValid(strEq))
{
SetFocus();
return;
}
UpdateGraph();
}
//
// Change aperture stored in project
//
bool CChooseApertureDlg::Execute(CFrameSet &fset, const CApertures &aper, const CSelection &sel, int *ap_index)
{
m_FrameSet = &fset;
m_Aper = aper;
m_Selection = sel;
m_ApertureIndex = *ap_index;
UpdateApertures();
UpdateChannels();
UpdateGraph(TRUE, TRUE);
if (gtk_dialog_run(GTK_DIALOG(m_pDlg))==GTK_RESPONSE_ACCEPT) {
*ap_index = m_ApertureIndex;
return true;
}
return false;
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::NewEffectButtonClick(TObject *Sender)
{
if (Application->MessageBox ("Do you wish to create a new effect ?", "Warning", MB_YESNO | MB_ICONSTOP) == IDNO)
return;
m_Animator->Create ();
UpdateGraph ();
m_props[tAddColor]->Clear();
m_props[tBaseColor]->Clear();
m_props[tGray]->Clear();
m_props[tDuality]->Clear();
m_props[tNoise]->Clear();
m_props[tBlur]->Clear();
}
void myGauge2::initVariables()
{
m_outerRadius=width()>height() ? height()/2: width()/2;
m_innerRadius=m_outerRadius/8*7;
m_coverCircleRadius=m_outerRadius/8*4+10;
m_colorCircleRadius=m_outerRadius/8*5;
m_center=rect().center();
m_value=0;
m_currentValue=0;
updateTimer=new QTimer(this);
updateTimer->setInterval(10);
connect(updateTimer,SIGNAL(timeout()),this,SLOT(UpdateGraph()));
singleTimer=new QTimer(this);
singleTimer->setInterval(100);
connect(singleTimer,SIGNAL(timeout()),this,SLOT(update()));
singleTimer->start();
}
// Read data
void AppWindow::OnOpen(BMessage *msg) {
entry_ref ref;
BMessage archive;
msg->FindRef("refs", &ref);
BFile file(&ref, B_READ_ONLY);
archive.Unflatten(&file);
Graph *g = (Graph*)Graph::Instantiate(&archive);
if (g != NULL) {
delete view->graph; view->graph = g;
BMenu *menu = data->functions->Menu();
while (menu->RemoveItem((int32)0) != NULL);
Function1 *f;
int i;
if (program->Lock()) {
program->view->SetText(g->GetDefinitions()->GetText());
program->Unlock();
}
MarkColorMenuItem(bg_color, view->graph->bg_color);
MarkColorMenuItem(axes_color, view->graph->axes_color);
ExprList *el = g->GetGraphExprs();
for (i = 0; i < 6; i++)
data->gCtrls[i]->SetText(el->GetText(i));
for (i = 0; i < 5; i++)
data->fCtrls[i]->SetText("");
UpdateGraph();
for (i = 0; NULL != (f = g->GetFunction(i)); i++) {
CompileFunction(f, false);
}
for (i = 0; NULL != (f = g->GetFunction(i)); i++)
AddFunction(f);
OnSelect();
OnUpdate();
} else {
BAlert *a = new BAlert("Open Error", "Could not read file.", "OK");
a->Go();
}
}
// Read all data, parse und evaluate it
bool AppWindow::CheckFunction() {
int i;
UpdateGraph();
for (i = 0; i < 5; i++) {
view->f1->Exprs()->SetText(i, data->fCtrls[i]->Text());
}
view->f1->SetVisible(data->visible->Value());
ColorMenuItem *c = (ColorMenuItem*)data->color->Menu()->FindMarked();
if (c != NULL) view->f1->SetColor(c->GetColor());
BMenuItem *item = data->style->Menu()->FindMarked();
if (item != NULL) view->f1->SetStyle(data->style->Menu()->IndexOf(item));
if (CompileFunction(view->f1, true)) {
statusLine->SetText("ok");
return true;
} else
return false;
}
myGauge1::myGauge1(QWidget *parent) :
QWidget(parent)
{
m_value=0;
m_currentValue=0;
m_bReverse=false;
updateTimer=new QTimer(this);
updateTimer->setInterval(10);
connect(updateTimer,SIGNAL(timeout()),this,SLOT(UpdateGraph()));
m_outerRadius=width()>height() ? height()/2 : width()/2;
m_innerRadius=0.8*m_outerRadius;
m_colorPieRadius=m_outerRadius*0.7;
m_coverCircleRadius=0.7*m_colorPieRadius;
m_center=rect().center();
m_longHand=(qreal)m_outerRadius/20;
m_okHand=0.7*m_longHand;
m_shortHand=0.5*m_longHand;
m_space=0.1*m_longHand;
}
AUI_ERRCODE LineGraph::DrawThis(aui_Surface *surface, sint32 x, sint32 y )
{
if ( !m_draw )
m_draw = k_AUI_REGION_DRAWFLAG_UPDATE;
if (!(m_draw && k_AUI_REGION_DRAWFLAG_UPDATE)) return AUI_ERRCODE_OK;
if ( !surface )
surface = m_window->TheSurface();
RECT rect = { 0, 0, m_width, m_height };
OffsetRect( &rect, m_x + x, m_y + y );
ToWindow( &rect );
UpdateGraph(surface, rect.left, rect.top);
if ( surface == m_window->TheSurface() )
m_window->AddDirtyRect( &rect );
return AUI_ERRCODE_OK;
}
void __fastcall TMainForm::TabControlChange(TObject *Sender)
{
if (m_ActiveShowForm)
{
m_ActiveShowForm->GetForm()->Visible = false;
m_ActiveShowForm = NULL;
}
m_ActiveShowForm = m_props[TabControl->TabIndex];
m_ActiveShowForm->GetForm()->Parent = WorkArea;
m_ActiveShowForm->GetForm()->Left = 0;
m_ActiveShowForm->GetForm()->Top = 0;
m_ActiveShowForm->GetForm()->Width = WorkArea->Width;
m_ActiveShowForm->GetForm()->Height = WorkArea->Height;
m_ActiveShowForm->GetForm()->Visible = true;
FillPointList ();
if(PointList->Count)
PointList->ItemIndex = 0;
PointListClick (NULL);
UpdateGraph ();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::FormPaint(TObject *Sender)
{
UpdateGraph ();
}
/****************************************************************************
Function:
WORD GOLDrawCallback( void )
Description:
This callback is performed at the beginning of the GOLDraw() function.
Processing that needs to be done on a regular basis and is not triggered
by a message should be done here.
Precondition:
None
Parameters:
None
Returns:
None
Remarks:
All graphic control adding and removing must be done from this function,
not from the message callback.
***************************************************************************/
WORD GOLDrawCallback( void )
{
switch (screenState)
{
// Display Start-up screen and play Welcome message
case SCREEN_START:
// Display the start up screen
PictCreate( ID_ICON, // ID
0,0,GetMaxX(),GetMaxY(), // dimension
PICT_DRAW, // will be displayed, has frame
1, // scale factor is x1
picture, // bitmap
NULL ); // default GOL scheme
screenState = SCREEN_START_DELAY;
break;
case SCREEN_START_DELAY:
if(enableSoundFlag)
{
while(speakerBusy());
// Speaker: Welcome to MPLAB Starter Kit for PIC24H MCU Demonstration
speakerActivate(SPEECH_ADDR_WELCOME, SPEECH_SIZE_WELCOME);
Delay(6000);
}
// Initialize the reference timer
TickInit();
// Initialize the accelerometer
AccelerometerInit();
screenState = SCREEN_DISPLAY_MAIN;
break;
// Display Main screen
case SCREEN_DISPLAY_MAIN:
ShowScreenMain();
screenState = SCREEN_MAIN;
displayChangeTime = tick;
break;
case SCREEN_MAIN:
break;
// Display Accelerometer Tri-axial Outputs graph
case SCREEN_DISPLAY_GRAPH:
ShowScreenGraph();
screenState = SCREEN_GRAPH;
displayChangeTime = tick;
break;
case SCREEN_GRAPH:
AccelerometerStop();
UpdateGraph();
break;
// Display connect External Sensor information
case SCREEN_DISPLAY_ES_INFO:
ShowScreenESInfo();
screenState = SCREEN_ES_INFO;
displayChangeTime = tick;
break;
case SCREEN_ES_INFO:
Delay(2000);
screenState = SCREEN_DISPLAY_ES_GRAPH;
break;
// Display External Sensor output graph
case SCREEN_DISPLAY_ES_GRAPH:
AccelerometerStop();
ShowScreenESGraph();
initESADC();
screenState = SCREEN_ES_GRAPH;
displayChangeTime = tick;
break;
case SCREEN_ES_GRAPH:
UpdateESGraph();
break;
// Display Orientation screen
case SCREEN_DISPLAY_ORIENTATION:
ShowScreenOrientation();
screenState = SCREEN_ORIENTATION;
displayChangeTime = tick;
break;
case SCREEN_ORIENTATION:
UpdateOrientation();
break;
// Display Games screen
case SCREEN_DISPLAY_GAMES:
ShowScreenGames();
screenState = SCREEN_GAMES;
displayChangeTime = tick;
break;
case SCREEN_GAMES:
break;
// Display Bomber Jet screen
case SCREEN_DISPLAY_JET:
ShowScreenJet();
AccelerometerStop();
AccelerometerInit();
if(enableSoundFlag)
{
while(speakerBusy());
speakerActivate(SPEECH_ADDR_START, SPEECH_SIZE_START);
while(speakerBusy());
}
screenState = SCREEN_JET;
displayChangeTime = tick;
break;
case SCREEN_JET:
DrawJet();
break;
// Display Snake screen
case SCREEN_DISPLAY_SNAKE:
ShowScreenSnake();
AccelerometerStop();
AccelerometerInit();
if(enableSoundFlag)
{
while(speakerBusy());
speakerActivate(SPEECH_ADDR_START, SPEECH_SIZE_START);
while(speakerBusy());
}
screenState = SCREEN_SNAKE;
displayChangeTime = tick;
break;
case SCREEN_SNAKE:
DrawSnake();
break;
// Display Score screen
case SCREEN_DISPLAY_SCORE:
ShowScreenScore();
if(enableSoundFlag)
{
while(speakerBusy());
speakerActivate(SPEECH_ADDR_GAME, SPEECH_SIZE_GAME);
while(speakerBusy());
speakerActivate(SPEECH_ADDR_OVER, SPEECH_SIZE_OVER);
}
displayChangeTime = tick;
screenState = SCREEN_SCORE;
break;
case SCREEN_SCORE:
break;
}
return 1; // Callback complete
}
extern Boolean
XltWorking(Widget w, String Question, int PercentDone)
{
static Widget Dialog = NULL;
static WorkingData_t Data;
static Boolean abortflag = False;
static Boolean mapped = False;
XmString string;
if (Dialog == NULL)
{
Widget shell = w;
Widget frame;
Widget frame_title;
XGCValues values;
Dialog = XmCreateWorkingDialog(shell, "Working", NULL, 0);
XtVaSetValues(Dialog,
XmNautoUnmanage, False,
NULL);
XtUnmanageChild(XmMessageBoxGetChild(Dialog, XmDIALOG_HELP_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(Dialog, XmDIALOG_CANCEL_BUTTON));
XtAddCallback(Dialog, XmNokCallback, (XtCallbackProc)callback, &abortflag);
XtAddCallback(Dialog, XmNunmapCallback, (XtCallbackProc)callback, &abortflag);
XtAddEventHandler(XtParent(Dialog),
StructureNotifyMask,
False,
(XtEventHandler)StructureNotifyHandler,
(XtPointer)&mapped);
mapped = False;
frame = XmCreateFrame(Dialog,"Frame",NULL,0);
frame_title = XmCreateLabel(frame,"Title", NULL,0);
XtVaSetValues(frame_title,
XmNchildType, XmFRAME_TITLE_CHILD,
NULL);
Data.Da = XmCreateDrawingArea(frame, "Graph", NULL, 0);
XtManageChild(frame_title);
XtManageChild(Data.Da);
XtManageChild(frame);
XtRealizeWidget(Dialog);
Data.Id = (XtIntervalId)NULL;
XtVaGetValues(Data.Da,
XmNforeground, &values.foreground,
XmNbackground, &values.background,
NULL);
Data.gc = XCreateGC(XtDisplay(Data.Da),
XtWindow(Data.Da),
GCForeground | GCBackground, &values);
}
if (Question)
{
string = XmStringCreateSimple(Question);
XtVaSetValues(Dialog,
XmNmessageString, string,
NULL);
XmStringFree(string);
}
if (PercentDone >= 0)
{
Data.percent = PercentDone;
}
switch (PercentDone)
{
case 0:
abortflag = False;
XtManageChild(Dialog);
if (Data.Id == (XtIntervalId)NULL)
{
XClearArea(XtDisplay(Data.Da),
XtWindow(Data.Da),
0, 0, 0, 0, False);
Data.Id = XtAppAddTimeOut(XtWidgetToApplicationContext(Dialog),
0, (XtTimerCallbackProc)UpdateGraph, &Data);
}
break;
case 100:
if (Data.Id != (XtIntervalId)NULL)
{
XtRemoveTimeOut(Data.Id);
Data.Id = (XtIntervalId)NULL;
}
while (XtIsManaged(Dialog) && !mapped)
{
XtAppProcessEvent(XtWidgetToApplicationContext(Dialog), XtIMXEvent);
}
UpdateGraph(&Data);
XtRemoveTimeOut(Data.Id);
Data.Id = (XtIntervalId)NULL;
XtUnmanageChild(Dialog);
while (!XtIsManaged(Dialog) && mapped)
{
XtAppProcessEvent(XtWidgetToApplicationContext(Dialog), XtIMXEvent);
}
abortflag = False;
break;
default:
{
XtInputMask mask;
while ((mask = (XtAppPending(XtWidgetToApplicationContext(Dialog)) & ~XtIMAlternateInput)))
{
XtAppProcessEvent(XtWidgetToApplicationContext(Dialog), mask);
}
if (!XtIsManaged(Dialog))
{
abortflag = True;
}
}
break;
}
return(abortflag);
}
//---------------------------------------------------------------------------
void TMainForm::SetMarkerPosition (float time)
{
m_Marker = time;
UpdateGraph ();
}
//-----------------------------------------------------------------------------
//!
//-----------------------------------------------------------------------------
void tWindPlotGraph::SetTimeRange(TimePlot::eTimePlotRange timePlotRange)
{
m_TimePlotRange = timePlotRange;
UpdateGraph();
}
//-----------------------------------------------------------------------------
//!
//-----------------------------------------------------------------------------
void tWindPlotGraph::OnUnitsChanged( tUnitsType unitsType, int value )
{
Q_UNUSED( unitsType );
Q_UNUSED( value );
UpdateGraph();
}
WORD GOLDrawCallback( void )
{
unsigned char i;
OBJ_HEADER *pObject;
extern unsigned int trip[NUM_TOUCHPADS];
switch (screenState)
{
case SCREEN_BOARD_TEST:
PerformBoardTest();
break;
case SCREEN_DISPLAY_MAIN:
ShowScreenMain();
displayChangeTime = tick;
screenState = SCREEN_MAIN;
break;
case SCREEN_MAIN:
RTCCProcessEvents();
if (previousSecond != _time_str[11])
{
previousSecond = _time_str[11];
strcpy( pageInformation.instructions, _date_str );
strcat( pageInformation.instructions, " " );
strcat( pageInformation.instructions, _time_str );
pObject = GOLFindObject( ID_INSTRUCTIONS );
StSetText( (STATICTEXT *)pObject, pageInformation.instructions );
SetState( pObject, ST_DRAW );
}
break;
case SCREEN_DISPLAY_FLASH:
ShowScreenFlash();
displayChangeTime = tick;
screenState = SCREEN_FLASH;
break;
case SCREEN_FLASH:
FlashMonitorMedia();
break;
case SCREEN_DISPLAY_FLASH_ERROR:
ShowScreenFlashError();
displayChangeTime = tick;
screenState = SCREEN_FLASH_ERROR;
break;
case SCREEN_FLASH_ERROR:
break;
case SCREEN_DISPLAY_GAMES:
ShowScreenGames();
displayChangeTime = tick;
screenState = SCREEN_GAMES;
break;
case SCREEN_GAMES:
break;
case SCREEN_DISPLAY_SNAKE:
ShowScreenSnake();
displayChangeTime = tick;
screenState = SCREEN_SNAKE;
break;
case SCREEN_SNAKE:
DrawSnake();
break;
case SCREEN_DISPLAY_SNAKE_SCORE:
ShowScreenScore();
displayChangeTime = tick;
screenState = SCREEN_SNAKE_SCORE;
break;
case SCREEN_SNAKE_SCORE:
break;
case SCREEN_DISPLAY_BLASTER:
ShowScreenBlaster();
// Set the touchpad sensitivity for quicker game play.
for (i=0; i<NUM_TOUCHPADS; i++)
{
trip[i]=TRIP_VALUE_BLASTER;
}
displayChangeTime = tick;
screenState = SCREEN_BLASTER;
break;
case SCREEN_BLASTER:
DrawBlaster();
break;
case SCREEN_DISPLAY_BLASTER_SCORE:
ShowScreenScore();
// Reset the touchpad sensitivity to normal.
for(i=0; i<NUM_TOUCHPADS; i++)
{
trip[i]=TRIP_VALUE;
}
displayChangeTime = tick;
screenState = SCREEN_BLASTER_SCORE;
break;
case SCREEN_BLASTER_SCORE:
break;
case SCREEN_DISPLAY_SHAPELET:
ShowScreenShapelet();
displayChangeTime = tick;
screenState = SCREEN_SHAPELET;
break;
case SCREEN_SHAPELET:
break;
case SCREEN_DISPLAY_SHAPELET_SCORE:
ShowScreenScore();
displayChangeTime = tick;
screenState = SCREEN_SHAPELET_SCORE;
break;
case SCREEN_SHAPELET_SCORE:
break;
case SCREEN_DISPLAY_DEMOS:
ShowScreenDemos();
displayChangeTime = tick;
screenState = SCREEN_DEMOS;
break;
case SCREEN_DEMOS:
break;
case SCREEN_DISPLAY_RGB:
ShowScreenRGB();
displayChangeTime = tick;
screenState = SCREEN_RGB;
break;
case SCREEN_RGB:
break;
case SCREEN_DISPLAY_GRAPH:
ShowScreenGraph();
displayChangeTime = tick;
screenState = SCREEN_GRAPH;
break;
case SCREEN_GRAPH:
UpdateGraph();
break;
case SCREEN_DISPLAY_CAPTURE_MEDIA:
ShowScreenCaptureMedia();
displayChangeTime = tick;
screenState = SCREEN_CAPTURE_MEDIA;
break;
case SCREEN_CAPTURE_MEDIA:
CaptureMonitorMedia();
break;
case SCREEN_DISPLAY_CAPTURE:
ShowScreenCapture();
displayChangeTime = tick;
screenState = SCREEN_CAPTURE;
break;
case SCREEN_CAPTURE:
UpdateGraph();
CaptureMonitorMedia();
break;
case SCREEN_DISPLAY_UTILITIES:
ShowScreenUtilities();
displayChangeTime = tick;
screenState = SCREEN_UTILITIES;
break;
case SCREEN_UTILITIES:
break;
case SCREEN_DISPLAY_TIME:
ShowScreenTime();
displayChangeTime = tick;
screenState = SCREEN_TIME;
break;
case SCREEN_TIME:
break;
case SCREEN_DISPLAY_CTMU:
ShowScreenCTMU();
displayChangeTime = tick;
screenState = SCREEN_CTMU;
break;
case SCREEN_CTMU:
CalibrateCTMU();
break;
case SCREEN_DISPLAY_BAR_DEMO:
ShowScreenBarDemo();
displayChangeTime = tick;
screenState = SCREEN_BAR_DEMO;
break;
case SCREEN_BAR_DEMO:
DrawBarDemo();
break;
}
return 1; // Callback complete
}
/*********************************************************************
* Function: WORD GOLDrawCallback()
*
* Overview: GOLDrawCallback() function MUST BE implemented by
* the user. This is called inside the GOLDraw()
* function when the drawing of objects in the active
* list is completed. User drawing must be done here.
* Drawing color, line type, clipping region, graphic
* cursor position and current font will not be changed
* by GOL if this function returns a zero. To pass
* drawing control to GOL this function must return
* a non-zero value. If GOL messaging is not using
* the active link list, it is safe to modify the
* list here.
*
* PreCondition: none
*
* Input: none
*
* Output: Return a one if GOLDraw() will have drawing control
* on the active list. Return a zero if user wants to
* keep the drawing control.
*
* Example:
* <CODE>
* #define SIG_STATE_SET 0
* #define SIG_STATE_DRAW 1
* WORD GOLDrawCallback(){
* static BYTE state = SIG_STATE_SET;
* if(state == SIG_STATE_SET){
* // Draw the button with disabled colors
* GOLPanelDraw(SIG_PANEL_LEFT,SIG_PANEL_TOP,
* SIG_PANEL_RIGHT,SIG_PANEL_BOTTOM, 0,
* WHITE, altScheme->EmbossLtColor,
* altScheme->EmbossDkColor,
* NULL, GOL_EMBOSS_SIZE);
*
* state = SIG_STATE_DRAW;
* }
*
* if(!GOLPanelDrawTsk()){
* // do not return drawing control to GOL
* // drawing is not complete
* return 0;
* }else{
* state = SIG_STATE_SET;
* // return drawing control to GOL, drawing is complete
* return 1;
* }
* }
* </CODE>
*
* Side Effects: none
*
********************************************************************/
WORD GOLDrawCallback(void)
{
UpdateGraph();
return 1;
}
