void TMOGUIToneSlider::mouseDoubleClickEvent ( QMouseEvent * e )
{
if (e->y() > 9)
{
if ((e->x() > iWhite - 5)&&(e->x() < iWhite + 5))
{
iWhite = s.width() - 1;
}
else if ((e->x() > iBlack - 5)&&(e->x() < iBlack + 5))
{
iBlack = 0;
}
else if ((e->x() > iGamma - 5)&&(e->x() < iGamma + 5))
{
iGamma = (iWhite + iBlack) / 2;
UpdateValues();
pValues->RenderValues();
return;
}
}
else if ((e->x() > iBlack - 1) && (e->x() < iWhite + 1))
{
iWhite = s.width() - 1;
iBlack = 0;
iGamma = (iWhite + iBlack) / 2;
UpdateValues();
pValues->RenderValues();
return;
}
UpdateValues(false);
correct_iGamma();
pValues->RenderValues();
}
/**
* This method is called periodically to cause the sensors to send new values
* to the SmartDashboard.
*/
void LiveWindow::Run()
{
if (m_enabled)
{
UpdateValues();
}
}
wxString pgSequence::GetSql(ctlTree *browser)
{
if (sql.IsNull())
{
UpdateValues();
sql = wxT("-- Sequence: ") + GetQuotedFullIdentifier() + wxT("\n\n")
+ wxT("-- DROP SEQUENCE ") + GetQuotedFullIdentifier() + wxT(";")
+ wxT("\n\nCREATE SEQUENCE ") + GetQuotedFullIdentifier()
+ wxT("\n INCREMENT ") + GetIncrement().ToString()
+ wxT("\n MINVALUE ") + GetMinValue().ToString()
+ wxT("\n MAXVALUE ") + GetMaxValue().ToString()
+ wxT("\n START ") + GetLastValue().ToString()
+ wxT("\n CACHE ") + GetCacheValue().ToString();
if (GetCycled())
sql += wxT("\n CYCLE");
sql += wxT(";\n")
+ GetOwnerSql(7, 3, wxT("TABLE ") + GetQuotedFullIdentifier());
if (!GetConnection()->BackendMinimumVersion(8, 2))
sql += GetGrant(wxT("arwdRxt"), wxT("TABLE ") + GetQuotedFullIdentifier());
else
sql += GetGrant(wxT("rwU"), wxT("TABLE ") + GetQuotedFullIdentifier());
sql += GetCommentSql();
if (GetConnection()->BackendMinimumVersion(9, 1))
sql += GetSeqLabelsSql();
}
return sql;
}
void pgSequence::ShowTreeDetail(ctlTree *browser, frmMain *form, ctlListView *properties, ctlSQLBox *sqlPane)
{
UpdateValues();
if (properties)
{
CreateListColumns(properties);
properties->AppendItem(_("Name"), GetName());
properties->AppendItem(_("OID"), GetOid());
properties->AppendItem(_("Owner"), GetOwner());
properties->AppendItem(_("ACL"), GetAcl());
properties->AppendItem(_("Current value"), GetLastValue());
properties->AppendItem(_("Next value"), GetNextValue());
properties->AppendItem(_("Minimum"), GetMinValue());
properties->AppendItem(_("Maximum"), GetMaxValue());
properties->AppendItem(_("Increment"), GetIncrement());
properties->AppendItem(_("Cache"), GetCacheValue());
properties->AppendYesNoItem(_("Cycled?"), GetCycled());
properties->AppendYesNoItem(_("Called?"), GetCalled());
properties->AppendYesNoItem(_("System sequence?"), GetSystemObject());
properties->AppendItem(_("Comment"), firstLineOnly(GetComment()));
if (!GetLabels().IsEmpty())
{
wxArrayString seclabels = GetProviderLabelArray();
if (seclabels.GetCount() > 0)
{
for (unsigned int index = 0 ; index < seclabels.GetCount() - 1 ; index += 2)
{
properties->AppendItem(seclabels.Item(index), seclabels.Item(index + 1));
}
}
}
}
}
/** \fn SignalMonitor::MonitorLoop()
* \brief Basic signal monitoring loop
*/
void SignalMonitor::MonitorLoop()
{
running = true;
exit = false;
while (!exit)
{
UpdateValues();
if (notify_frontend && capturecardnum>=0)
{
QStringList slist = GetStatusList(false);
MythEvent me(QString("SIGNAL %1").arg(capturecardnum), slist);
gCoreContext->dispatch(me);
//cerr<<"sent SIGNAL"<<endl;
}
usleep(update_rate * 1000);
}
// We need to send a last informational message because a
// signal update may have come in while we were sleeping
// if we are using the multithreaded dtvsignalmonitor.
if (notify_frontend && capturecardnum>=0)
{
QStringList slist = GetStatusList(false);
MythEvent me(QString("SIGNAL %1").arg(capturecardnum), slist);
gCoreContext->dispatch(me);
}
running = false;
}
NS_IMETHODIMP
Observe(nsISupports* aSubject,
const char* aTopic,
const char16_t* aData) override
{
UpdateValues();
return NS_OK;
}
void TMOGUIToneSlider::setToWidth()
{
iWhite = s.width() - 1;
iBlack = 0;
iGamma = (iWhite + iBlack) / 2;
UpdateValues();
pValues->RenderValues();
}
MagicDocDlgOptions::MagicDocDlgOptions(wxWindow *parent, wxWindowID id,
const wxString &title, const wxPoint &pos, const wxSize &size,
long style, const wxString &name):
wxDialog(parent, id, title, pos, size, style, name)
{
wxPanel* panel_generic;
wxStdDialogButtonSizer *dlg_sizer;
wxButton *btn_ok, *btn_cancel, *btn_apply;
wxButton *btn_depotPath;
wxStaticBoxSizer *static_sizer;
wxStaticText *st_depotPath;
wxBoxSizer *sizer_main;
wxBoxSizer *sizer_depotPath;
btn_ok = new wxButton(this, wxID_OK);
btn_cancel = new wxButton(this, wxID_CANCEL);
btn_apply = new wxButton(this, wxID_APPLY);
panel_generic = new wxPanel( this, -1, wxDefaultPosition, wxSize(200, 200) );
st_depotPath = new wxStaticText( panel_generic, -1, wxT("Depot path: ") );
tc_depotPath = new wxTextCtrl( panel_generic, -1, EMPTY_STRING, wxDefaultPosition,
wxSize(200, 22) );
btn_depotPath = new wxButton( panel_generic, ID_OPTION_EXPLORE, wxT("Explore...") );
cb_copyOnImport = new wxCheckBox( panel_generic, -1, wxT("Copy file while importing document") );
cb_confirmDelete = new wxCheckBox( panel_generic, -1, wxT("Confirm for deleting document") );
sizer_depotPath = new wxBoxSizer(wxHORIZONTAL);
sizer_depotPath->Add(st_depotPath);
sizer_depotPath->Add(tc_depotPath);
sizer_depotPath->Add(btn_depotPath);
static_sizer = new wxStaticBoxSizer( wxVERTICAL, panel_generic, wxT("Generic Settings") );
static_sizer->Add( sizer_depotPath );
static_sizer->Add( cb_copyOnImport );
static_sizer->Add( cb_confirmDelete );
panel_generic->SetSizer(static_sizer);
dlg_sizer = new wxStdDialogButtonSizer();
dlg_sizer->AddButton(btn_ok);
dlg_sizer->AddButton(btn_cancel);
dlg_sizer->AddButton(btn_apply);
dlg_sizer->Realize();
sizer_main = new wxBoxSizer(wxVERTICAL);
sizer_main->Add(panel_generic, 1, wxEXPAND);
sizer_main->Add(dlg_sizer);
SetSizer(sizer_main);
Layout();
readConfig();
UpdateValues();
}
void KeyDown(WPARAM wParam, LPARAM lParam)
{
int value;
switch(wParam)
{
// Right, increase frequency
case VK_RIGHT:
if (++scale.value > FREQ_MAX)
scale.value = FREQ_MAX;
break;
// Left, decrease frequency
case VK_LEFT:
if (--scale.value < FREQ_MIN)
scale.value = FREQ_MIN;
break;
// Up, increase fine frequency (sliders are backwards)
case VK_UP:
value = SendMessage(fine.hwnd, TBM_GETPOS, 0, 0);
SendMessage(fine.hwnd, TBM_SETPOS, TRUE, --value);
break;
// Down, decrease fine frequency
case VK_DOWN:
value = SendMessage(fine.hwnd, TBM_GETPOS, 0, 0);
SendMessage(fine.hwnd, TBM_SETPOS, TRUE, ++value);
break;
// Page up, increase level (sliders are backwards)
case VK_PRIOR:
value = SendMessage(level.hwnd, TBM_GETPOS, 0, 0);
SendMessage(level.hwnd, TBM_SETPOS, TRUE, --value);
break;
// Page down, decrease level
case VK_NEXT:
value = SendMessage(level.hwnd, TBM_GETPOS, 0, 0);
SendMessage(level.hwnd, TBM_SETPOS, TRUE, ++value);
break;
default:
return;
}
UpdateValues();
}
static void OnBrightnessData(DataField *Sender,
DataField::DataAccessMode Mode){
switch(Mode){
case DataField::daChange:
BrightnessValue = Sender->GetAsInteger();
UpdateValues();
break;
case DataField::daSpecial:
return;
}
}
//-------------------------------------------------------------------------------------------
//! Utility method to help setup data items
//-------------------------------------------------------------------------------------------
tDataGraph* tContextPanelCommon::GetConfiguredDataGraph( tDataType dataType,
unsigned char instance,
tDataGraph::eDisplayMode displayMode,
QSize size,
QPoint position ) const
{
Assert( m_pDataUpdateTimer != 0 );
tDataGraph* pGraph = new tDataGraph( dataType, size, instance, displayMode );
pGraph->setPos( position );
Connect( m_pDataUpdateTimer, SIGNAL( Timeout500ms() ), pGraph, SLOT( UpdateValues() ) );
return pGraph;
}
void
ATCReferencePanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
RowFormWidget::Prepare(parent, rc);
AddReadOnly(_("Waypoint"));
AddReadOnly(_("Location"));
AddButton(_("Relocate"), *this, RELOCATE);
AddButton(_("Clear"), *this, CLEAR);
UpdateValues();
}
static void OnAutoData(DataField *Sender, DataField::DataAccessMode Mode){
DataFieldBoolean &df = *(DataFieldBoolean *)Sender;
switch(Mode){
case DataField::daChange:
EnableAutoBrightness = df.GetAsBoolean();
UpdateValues();
break;
case DataField::daSpecial:
return;
}
}
void
ATCReferencePanel::OnAction(int id) noexcept
{
GeoPoint &location =
CommonInterface::SetComputerSettings().poi.atc_reference;
switch (id) {
case RELOCATE: {
auto waypoint = ShowWaypointListDialog(CommonInterface::Basic().location);
if (waypoint != nullptr) {
location = waypoint->location;
UpdateValues();
}
}
break;
case CLEAR:
location.SetInvalid();
UpdateValues();
break;
}
}
void Collision::DataStructures::BoundingBox::UpdateValuesUnsorted(glm::vec3 p1, glm::vec3 p2, glm::vec3 p3, glm::vec3 p4)
{
glm::vec3 minCoords, maxCoords;
minCoords.x = (p1.x < p2.x && p1.x < p3.x && p1.x < p4.x) ? p1.x : (p2.x < p3.x && p2.x < p4.x) ? p2.x : (p3.x < p4.x) ? p3.x : p4.x;
minCoords.y = (p1.y < p2.y && p1.y < p3.y && p1.y < p4.y) ? p1.y : (p2.y < p3.y && p2.y < p4.y) ? p2.y : (p3.y < p4.y) ? p3.y : p4.y;
minCoords.z = (p1.z < p2.z && p1.z < p3.z && p1.z < p4.z) ? p1.z : (p2.z < p3.z && p2.z < p4.z) ? p2.z : (p3.z < p4.z) ? p3.z : p4.z;
maxCoords.x = (p1.x > p2.x && p1.x > p3.x && p1.x > p4.x) ? p1.x : (p2.x > p3.x && p2.x > p4.x) ? p2.x : (p3.x > p4.x) ? p3.x : p4.x;
maxCoords.y = (p1.y > p2.y && p1.y > p3.y && p1.y > p4.y) ? p1.y : (p2.y > p3.y && p2.y > p4.y) ? p2.y : (p3.y > p4.y) ? p3.y : p4.y;
maxCoords.z = (p1.z > p2.z && p1.z > p3.z && p1.z > p4.z) ? p1.z : (p2.z > p3.z && p2.z > p4.z) ? p2.z : (p3.z > p4.z) ? p3.z : p4.z;
UpdateValues(minCoords, maxCoords);
}
void
dlgSwitchesShowModal(void)
{
wf = LoadDialog(CallBackTable, XCSoarInterface::main_window,
_T("IDR_XML_SWITCHES"));
if (wf == NULL)
return;
wf->SetTimerNotify(OnTimerNotify);
UpdateValues();
wf->ShowModal();
delete wf;
}
void dlgBrightnessShowModal(){
wf = LoadDialog(CallBackTable, UIGlobals::GetMainWindow(),
_T("IDR_XML_BRIGHTNESS"));
if (wf == NULL)
return;
LoadFormProperty(*wf, _T("prpBrightness"), BrightnessValue);
LoadFormProperty(*wf, _T("prpAuto"), EnableAutoBrightness);
wf->ShowModal();
UpdateValues();
delete wf;
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
tEcoModeOnTargetPage::tEcoModeOnTargetPage( QSize size, tMercuryDataUpdateTimer* pUpdateTimer, tMercuryECOMode* pEcoData, QGraphicsItem* pParent )
: tContextPage( size, "", pUpdateTimer, pParent ),
m_pEcoDataLayer( pEcoData ),
m_ValueStyle( MercuryPalette::GetTextStyle( MercuryPalette::eF31 ) ),
m_UnitsStyle( MercuryPalette::GetTextStyle( MercuryPalette::eF32 ) ),
m_ValueFontPixelSize( m_ValueStyle.font.pixelSize() )
{
Assert( m_pEcoDataLayer );
m_EcoValueStr = "---";
m_UnitsStr = tConvert::Instance()->GetUnitsString( UNITS_ECONOMY );
m_EcoValuePt = QPoint( qRound( AvailableRect().width() * 0.08f ), qRound( AvailableRect().height() * 0.6f ) );
m_OptStringPt = QPoint( m_EcoValuePt.x(), qRound( m_EcoValuePt.y() * 1.3f ) );
Connect( m_pDataUpdateTimer, SIGNAL( Timeout200ms() ), this, SLOT( UpdateValues() ) );
}
void tGauge::ChangeDataType( const tDataId& dataId )
{
m_SaveLimits = false;
if( dataId == DATA_TYPE_INVALID )
{
return;
}
//clear existing indicators
m_Indicators.clear();
m_Indicators << tIndicator( dataId );
//set captions and limits
tDigitalData pData( dataId );
AbsoluteLimits = pData.AbsoluteLimitsConverted();
tFloatLimits limits( pData.MinConverted(), pData.MaxConverted() );
tFloatLimits warnings( pData.WarningLowConverted(), pData.WarningHighConverted() );
m_UnitsType = pData.Units();
m_UnitsValue = tUnitsSettings::Instance()->Units( m_UnitsType );
//set update timer and update immediately
UpdateValues();
//autoconfigure if applicable
if( CanAutoConfigure() && AutoConfigure() )
{
DoAutoConfigure();
}
SetLimits( limits, warnings );
SetCaptions();
//does any type specific config
ReconfigureGauge();
m_BackIsCached = false;
m_ForeIsCached = false;
update();
m_Modified = true;
if( m_UnitsType != UNITS_ECONOMY )
{
// m_SaveLimits = true;
}
}
/** \fn SignalMonitor::GetStatusList(bool)
* \brief Returns QStringList containing all signals and their current
* values.
*
* This serializes the signal monitoring values so that they can
* be passed from a backend to a frontend.
*
* SignalMonitorValue::Parse(const QStringList&) will convert this
* to a vector of SignalMonitorValue instances.
*
* \param kick if true Kick() will be employed so that this
* call will not have to wait for the next signal
* monitoring event.
*/
QStringList SignalMonitor::GetStatusList(bool kick)
{
if (kick && running)
Kick();
else if (!running)
UpdateValues();
QStringList list;
statusLock.lock();
list<<channelTuned.GetName()<<channelTuned.GetStatus();
list<<signalLock.GetName()<<signalLock.GetStatus();
if (HasFlags(kSigMon_WaitForSig))
list<<signalStrength.GetName()<<signalStrength.GetStatus();
statusLock.unlock();
return list;
}
/** \fn SignalMonitor::WaitForLock(int)
* \brief Wait for a StatusSignaLock(int) of true.
*
* This can be called whether or not the signal
* monitoring thread has been started.
*
* \param timeout maximum time to wait in milliseconds.
* \return true if signal was acquired.
*/
bool SignalMonitor::WaitForLock(int timeout)
{
statusLock.lock();
if (-1 == timeout)
timeout = signalLock.GetTimeout();
statusLock.unlock();
if (timeout<0)
return false;
MythTimer t;
t.start();
if (running)
{
while (t.elapsed()<timeout && running)
{
Kick();
statusLock.lock();
bool ok = signalLock.IsGood();
statusLock.unlock();
if (ok)
return true;
usleep(50);
}
if (!running)
return WaitForLock(timeout-t.elapsed());
}
else
{
while (t.elapsed()<timeout && !running)
{
UpdateValues();
statusLock.lock();
bool ok = signalLock.IsGood();
statusLock.unlock();
if (ok)
return true;
usleep(50);
}
if (running)
return WaitForLock(timeout-t.elapsed());
}
return false;
}
OOBB::OOBB(Collidable* d){
myOwner =d;
maxOOBB = myOwner->collisionModel->maxPointAABB;
minOOBB = myOwner->collisionModel->minPointAABB;
ComputeCorners();
UpdateValues();
Vect scale = (maxOOBB-minOOBB);
tempPos = ((maxOOBB+minOOBB)*.5f);
translationM.set(TRANS,tempPos);
scaleM.set(SCALE,scale[x],scale[y],scale[z]);
rotationM.set(ROT_XYZ,0,0,0);
//update cheap sphere vars
cheapSphereRadius = (scale).mag()*.5f;
//DrawColVolume(Vect(1,0,1));
}
/// \brief Basic signal monitoring loop
void SignalMonitor::run(void)
{
RunProlog();
QMutexLocker locker(&startStopLock);
running = true;
startStopWait.wakeAll();
while (!exit)
{
locker.unlock();
UpdateValues();
if (notify_frontend && capturecardnum>=0)
{
QStringList slist = GetStatusList();
MythEvent me(QString("SIGNAL %1").arg(capturecardnum), slist);
gCoreContext->dispatch(me);
}
locker.relock();
startStopWait.wait(locker.mutex(), update_rate);
}
// We need to send a last informational message because a
// signal update may have come in while we were sleeping
// if we are using the multithreaded dtvsignalmonitor.
locker.unlock();
if (notify_frontend && capturecardnum>=0)
{
QStringList slist = GetStatusList();
MythEvent me(QString("SIGNAL %1").arg(capturecardnum), slist);
gCoreContext->dispatch(me);
}
locker.relock();
running = false;
startStopWait.wakeAll();
RunEpilog();
}
void CControlPanel::ListenToMessage(MessageT inMessage, void* ioParam)
{
LStaticText *theCaption;
switch (inMessage) {
case msg_BroadcasterDied:
// maybe you should just
StopListening();
break;
case msg_RenderModeChanged:
_renderingMode = *((UInt32*)ioParam);
BroadcastMessage(msg_RenderModeChanged, ioParam);
break;
}
UpdateValues(true);
BroadcastMessage(msg_ControllerChanged ,nil);
}
CControlPanel::CControlPanel()
{
_totalMem = 0;
_renderingMode = 0;
_floatWindow = LWindow::CreateWindow(PPob_ControlWindow, this);
if (_floatWindow) {
// Get the main multi panel view and load up all the panels
LMultiPanelView* mainMPV = dynamic_cast<LMultiPanelView*> (_floatWindow->FindPaneByID(item_ControlMainPanelView));
ThrowIfNil_(mainMPV);
mainMPV->CreateAllPanels();
LPageController* thePage = dynamic_cast<LPageController*> (_floatWindow->FindPaneByID(item_ControlPageController));
ThrowIfNil_(thePage);
thePage->AddListener(mainMPV);
LView* theRenderingView = dynamic_cast<LView*> (_floatWindow->FindPaneByID(kRenderingView));
LView* thePositionView = dynamic_cast<LView*> (_floatWindow->FindPaneByID(kPositionView));
LView* theAnimationView = dynamic_cast<LView*> (_floatWindow->FindPaneByID(kAnimationView));
UReanimator::LinkListenerToControls(this, theRenderingView, PPob_RenderingView);
UReanimator::LinkListenerToControls(this, thePositionView, PPob_PositionView);
UReanimator::LinkListenerToControls(this, theAnimationView, PPob_AnimationView);
UpdateValues(true);
StartIdling();
_lastDraw = 0;
_drawInterval = 60; // in Ticks
// position
GDHandle dominantDevice = ::GetMainDevice();
Rect screenRect = (**dominantDevice).gdRect;
Rect windowBounds;
_floatWindow->GetGlobalBounds(windowBounds);
_floatWindow->MoveWindowTo(screenRect.right - (windowBounds.right - windowBounds.left + 13), ::GetMBarHeight() + 23 );
_floatWindow->Show();
}
}
void pgSequence::ShowTreeDetail(ctlTree *browser, frmMain *form, ctlListView *properties, ctlSQLBox *sqlPane)
{
UpdateValues();
if (properties)
{
CreateListColumns(properties);
properties->AppendItem(_("Name"), GetName());
properties->AppendItem(_("OID"), GetOid());
properties->AppendItem(_("Owner"), GetOwner());
properties->AppendItem(_("ACL"), GetAcl());
properties->AppendItem(_("Current value"), GetLastValue());
properties->AppendItem(_("Minimum"), GetMinValue());
properties->AppendItem(_("Maximum"), GetMaxValue());
properties->AppendItem(_("Increment"), GetIncrement());
properties->AppendItem(_("Cache"), GetCacheValue());
properties->AppendItem(_("Cycled?"), GetCycled());
properties->AppendItem(_("Called?"), GetCalled());
properties->AppendItem(_("System sequence?"), GetSystemObject());
properties->AppendItem(_("Comment"), firstLineOnly(GetComment()));
}
}
void InfoWidget::OnIdle(wxIdleEvent &event) {
if (m_update_current_value) {
int idx = m_draw->GetCurrentIndex();
if (idx >= 0)
m_val = m_draw->GetValuesTable().at(idx).val;
else
m_val = nan("");
SetValue(m_val);
m_update_current_value = false;
}
if (m_update_time) {
SetTime(m_current_time);
m_update_time = false;
}
if (m_update_values) {
UpdateValues();
m_update_values = false;
}
}
BOOL SliderChange(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
// Adjustments
case TB_PAGEDOWN:
case TB_PAGEUP:
break;
case TB_THUMBPOSITION:
case TB_THUMBTRACK:
break;
default:
return FALSE;
}
// Update
UpdateValues();
}
void Collision::DataStructures::BoundingBox::UpdateValuesUnsorted(glm::vec3 p1, glm::vec3 p2)
{
glm::vec3 minCoords, maxCoords;
if (p1.x < p2.x)
{
minCoords.x = p1.x;
maxCoords.x = p2.x;
}
else
{
minCoords.x = p2.x;
maxCoords.x = p1.x;
}
if (p1.y < p2.y)
{
minCoords.y = p1.y;
maxCoords.y = p2.y;
}
else
{
minCoords.y = p2.y;
maxCoords.y = p1.y;
}
if (p1.z < p2.z)
{
minCoords.z = p1.z;
maxCoords.z = p2.z;
}
else
{
minCoords.z = p2.z;
maxCoords.z = p1.z;
}
UpdateValues(minCoords, maxCoords);
}
void tGauge::showEvent( QShowEvent* /*event*/ )
{
if( m_ForcedHide )
{
//abort
hide();
return;
}
if( m_IsOverlay && !m_Registered )
{
QString name = objectName() + m_Indicators.at(0).dataId.ToVariant().toStringList().join( QString("") );
tOverlayManagerQueue::Instance()->RegisterOverlayWidget( this, tOverlayManagerQueue::OMPDigData, name );
m_Registered = true;
}
if( m_StartTimerID )
{
killTimer( m_StartTimerID );
}
m_StartTimerID = startTimer( m_StartDelay );
// if( GaugeType() == AnalogGauge )
// {
// bool disable = true;
//
// for( int i = 0; i < m_Indicators.size(); ++i )
// {
// tDigitalData pData( m_Indicators[ i ].dataId );
// if( pData.Valid() )
// disable = false;
// }
//
// setDisabled( disable );
// }
UpdateValues();
}
