void MapServerDlg::OnInitDialog(wxInitDialogEvent& event)
{
GetBaseUrl()->Clear();
int numservers = m_pServers->size();
for (int i = 0; i < numservers; i++)
{
wxString str(m_pServers->at(i).m_url, wxConvUTF8);
GetBaseUrl()->Append(str);
}
// If no selection, pick the first server
if (m_pServers->m_iSelected == -1 && numservers > 0)
m_pServers->m_iSelected = 0;
// Keep selection in range
if (m_pServers->m_iSelected >= numservers)
m_pServers->m_iSelected = numservers-1;
// Apply selection
if (m_pServers->m_iSelected != -1)
GetBaseUrl()->SetSelection(m_pServers->m_iSelected);
m_iServer = m_pServers->m_iSelected;
UpdateEnabling();
UpdateLayerList();
UpdateLayerDescription();
m_bSetting = true;
wxWindow::OnInitDialog(event);
m_bSetting = false;
}
void LocationDlg::SetAnimContainer(vtAnimContainer *ac)
{
m_pAnimPaths = ac;
m_iAnim = -1;
RefreshAnims();
UpdateSlider();
UpdateEnabling();
}
void LocationDlg::OnRecord1( wxCommandEvent &event )
{
TransferDataFromWindow();
vtAnimPathEngine *engine = GetEngine(m_iAnim);
vtTransform *xform = (vtTransform *) engine->GetTarget();
vtAnimPath *path = engine->GetAnimationPath();
FPoint3 pos = xform->GetTrans();
FQuat rot = xform->GetOrient();
ControlPoint cp(pos, rot);
float fTime;
if (path->NumPoints() == 0)
fTime = 0;
else
{
if (m_bRecordInterval)
{
// Record Interval: Append an element whose time is the desired number
// of seconds after the last point.
fTime = path->GetLastTime() + m_fRecordSpacing;
}
else
{
// RecordLinear: Append an element whose time is derived from the linear
// distance from the last point.
ControlPoint &prev_cp =
path->GetTimeControlPointMap().rbegin()->second;
float dist = (pos - prev_cp.m_Position).Length();
// convert directly at 1 meter/second
fTime = path->GetLastTime() + dist;
}
}
path->Insert(fTime, cp);
path->ProcessPoints();
wxString str;
str.Printf(_("%d: time %lf"), path->NumPoints()-1, fTime);
// Find the current animation
wxTreeItemId CurrentAnimation = GetAnimTree()->GetItemParent(m_current);
if (CurrentAnimation == m_root)
CurrentAnimation = m_current;
GetAnimTree()->AppendItem(CurrentAnimation, str);
RefreshAnimsText();
UpdateEnabling(); // Smooth might be allowed now
}
void LayerDlg::OnSelChanged( wxTreeEvent &event )
{
m_item = event.GetItem();
LayerItemData *data = GetLayerDataFromItem(m_item);
if (data && data->m_layer != NULL)
{
vtLayer *newlay = data->m_layer;
vtLayer *oldlay = m_pTerrain->GetActiveLayer();
if (newlay != oldlay)
{
m_pTerrain->SetActiveLayer(newlay);
UpdateTreeTerrain();
}
}
UpdateEnabling();
}
LocationDlg::LocationDlg( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &position, const wxSize& size, long style ) :
LocationDlgBase( parent, id, title, position, size, style )
{
m_bActive = true;
m_bLoop = true;
m_bContinuous = false;
m_bSmooth = true;
m_bPosOnly = false;
m_iAnim = -1;
m_iPos = 0;
m_fSpeed = 1.0f;
m_bSetting = false;
m_fRecordSpacing = 1.0f;
m_bRecordLinear = true;
m_bRecordInterval = false;
m_pSaver = NULL;
m_pAnimPaths = NULL;
m_pLocList = GetLoclist();
// Work around wxFormDesigner's lack of support for limiting to smallest size
GetSizer()->SetSizeHints(this);
AddValidator(this, ID_ACTIVE, &m_bActive);
AddValidator(this, ID_LOOP, &m_bLoop);
AddValidator(this, ID_CONTINUOUS, &m_bContinuous);
AddValidator(this, ID_SMOOTH, &m_bSmooth);
AddValidator(this, ID_POS_ONLY, &m_bPosOnly);
AddNumValidator(this, ID_SPEED, &m_fSpeed, 2);
AddValidator(this, ID_SPEEDSLIDER, &m_iSpeed);
AddNumValidator(this, ID_RECORD_SPACING, &m_fRecordSpacing);
AddValidator(this, ID_ANIM_POS, &m_iPos);
AddValidator(this, ID_RECORD_LINEAR, &m_bRecordLinear);
AddValidator(this, ID_RECORD_INTERVAL, &m_bRecordInterval);
RefreshButtons();
UpdateEnabling();
}
void LayerDlg::RefreshTreeContents()
{
if (!m_pTree)
return;
// start with a blank slate
m_pTree->DeleteAllItems();
switch (g_App.m_state)
{
case AS_Terrain:
RefreshTreeTerrain();
break;
case AS_Orbit:
RefreshTreeSpace();
break;
default:
break;
}
m_item = m_pTree->GetSelection();
UpdateEnabling();
}
void InstanceDlg::OnInitDialog(wxInitDialogEvent& event)
{
GetChoiceFile()->Clear();
for (uint i = 0; i < m_contents.size(); i++)
{
vtContentManager *mng = m_contents[i];
vtString str = mng->GetFilename();
wxString ws(str, wxConvUTF8);
GetChoiceFile()->Append(ws);
}
GetChoiceFile()->Select(0);
GetChoiceType()->Clear();
GetChoiceType()->Append(_("(All)"));
GetChoiceType()->Select(0);
UpdateLoc();
UpdateEnabling();
UpdateContentItems();
wxDialog::OnInitDialog(event);
}
void LocationDlg::OnTreeSelChanged( wxTreeEvent &event )
{
int previous = m_iAnim;
m_current = event.GetItem();
wxTreeItemId selid = m_current;
if (selid.IsOk())
{
// If they click on a subitem (point), look at its parent
wxTreeItemId parent = GetAnimTree()->GetItemParent(selid);
if (parent != m_root)
selid = parent;
// Look through the tree to find the index
wxTreeItemIdValue cookie;
wxTreeItemId id;
int count = 0;
for (id = GetAnimTree()->GetFirstChild(m_root, cookie);
id.IsOk();
id = GetAnimTree()->GetNextChild(m_root, cookie))
{
if (id == selid)
m_iAnim = count;
count++;
}
}
else
m_iAnim = -1;
if (previous != m_iAnim)
{
UpdateEnabling();
GetValues();
UpdateSlider();
ValuesToSliders();
TransferToWindow();
}
}
void LocationDlg::OnTreeKeyDown( wxTreeEvent &event )
{
if (event.GetKeyCode() != WXK_DELETE)
{
event.Skip();
return;
}
wxTreeItemId selid = m_current;
wxTreeItemId parent = GetAnimTree()->GetItemParent(selid);
if (parent == m_root)
{
// delete anim
m_pAnimPaths->erase(m_pAnimPaths->begin() + m_iAnim);
m_iAnim = -1;
RefreshAnims();
UpdateEnabling();
}
else
{
// delete point
wxTreeItemIdValue cookie;
wxTreeItemId id;
int count = 0;
for (id = GetAnimTree()->GetFirstChild(parent, cookie);
id.IsOk();
id = GetAnimTree()->GetNextChild(parent, cookie))
{
if (id == selid)
break;
count++;
}
vtAnimPath *anim = GetAnim(m_iAnim);
anim->RemovePoint(count);
GetAnimTree()->Delete(m_current);
}
}
//==============================================================================================
// FUNCTION: ClearDisplay
// PURPOSE:
//
void CMCTeleClientDlg::ClearDisplay()
{
// enable / disable connection parameter widgets
UpdateEnabling();
// clear the telegraph parameter display fields
m_cstrMode = "";
m_cstrPriSignal = "";
m_cstrPriAlpha = "";
m_cstrPriScaleFactor = "";
m_cstrPriLPFCutoff = "";
m_cstrSecSignal = "";
m_cstrSecAlpha = "";
m_cstrSecScaleFactor = "";
m_cstrSecLPFCutoff = "";
m_cstrMembraneCap = "";
m_cstrExtCmdSens = "";
m_cstrAppVer = "";
m_cstrDSPVer = "";
m_cstrFirmwareVer = "";
m_cstrSN = "";
UpdateData(FALSE);
}
//==============================================================================================
// FUNCTION: UpdateDisplay
// PURPOSE:
//
void CMCTeleClientDlg::UpdateDisplay()
{
// enable / disable connection parameter widgets
UpdateEnabling();
// update the telegraph parameter display fields
const unsigned int cuMaxDisplayStringSize = 128;
char pszTemp[cuMaxDisplayStringSize];
///////////////////////////////////////////////////////////////////
// operating mode
///////////////////////////////////////////////////////////////////
if(m_mctdCurrentState.uOperatingMode < MCTG_MODE_NUMCHOICES)
{
sprintf( pszTemp, MCTG_MODE_NAMES[m_mctdCurrentState.uOperatingMode] );
}
else
{
// this data is out of range
// handle as you will
sprintf(pszTemp, "Invalid Operating Mode!");
}
m_cstrMode = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// primary scaled output signal
///////////////////////////////////////////////////////////////////
if(m_mctdCurrentState.uScaledOutSignal < AXMCD_OUT_NAMES_NUMCHOICES)
{
sprintf( pszTemp, MCTG_OUT_GLDR_LONG_NAMES[m_mctdCurrentState.uScaledOutSignal] );
}
else
{
// this data is out of range
// handle as you will
sprintf(pszTemp, "Go Bombers!");
}
m_cstrPriSignal = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// secondary scaled output signal
///////////////////////////////////////////////////////////////////
if(m_mctdCurrentState.uRawOutSignal < AXMCD_OUT_NAMES_NUMCHOICES)
{
sprintf( pszTemp, MCTG_OUT_GLDR_LONG_NAMES[m_mctdCurrentState.uRawOutSignal] );
}
else
{
// this data is out of range
// handle as you will
sprintf(pszTemp, "Go Bombers!");
}
m_cstrSecSignal = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// primary alpha
///////////////////////////////////////////////////////////////////
sprintf(pszTemp, "%.3f", m_mctdCurrentState.dAlpha);
m_cstrPriAlpha = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// secondary alpha
///////////////////////////////////////////////////////////////////
sprintf(pszTemp, "%.3f", m_mctdCurrentState.dSecondaryAlpha);
m_cstrSecAlpha = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// primary scale factor and units
///////////////////////////////////////////////////////////////////
switch( m_mctdCurrentState.uScaleFactorUnits )
{
case MCTG_UNITS_VOLTS_PER_VOLT:
{
m_cstrPriScaleFactor.Format( "%0.2f V/V", m_mctdCurrentState.dScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_MILLIVOLT:
{
m_cstrPriScaleFactor.Format( "%0.2f V/mV", m_mctdCurrentState.dScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_MICROVOLT:
{
m_cstrPriScaleFactor.Format( "%0.2f V/µV", m_mctdCurrentState.dScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_AMP:
{
m_cstrPriScaleFactor.Format( "%0.2f V/A", m_mctdCurrentState.dScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_MILLIAMP:
{
m_cstrPriScaleFactor.Format( "%0.2f V/mA", m_mctdCurrentState.dScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_MICROAMP:
{
m_cstrPriScaleFactor.Format( "%0.2f V/µA", m_mctdCurrentState.dScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_NANOAMP:
{
m_cstrPriScaleFactor.Format( "%0.2f V/nA", m_mctdCurrentState.dScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_PICOAMP:
{
m_cstrPriScaleFactor.Format( "%0.2f V/pA", m_mctdCurrentState.dScaleFactor );
break;
}
default:
{
// invalid units identifier
ASSERT( FALSE );
break;
}
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// secondary scale factor and units
///////////////////////////////////////////////////////////////////
switch( m_mctdCurrentState.uRawScaleFactorUnits )
{
case MCTG_UNITS_VOLTS_PER_VOLT:
{
m_cstrSecScaleFactor.Format( "%0.2f V/V", m_mctdCurrentState.dRawScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_MILLIVOLT:
{
m_cstrSecScaleFactor.Format( "%0.2f V/mV", m_mctdCurrentState.dRawScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_MICROVOLT:
{
m_cstrSecScaleFactor.Format( "%0.2f V/µV", m_mctdCurrentState.dRawScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_AMP:
{
m_cstrSecScaleFactor.Format( "%0.2f V/A", m_mctdCurrentState.dRawScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_MILLIAMP:
{
m_cstrSecScaleFactor.Format( "%0.2f V/mA", m_mctdCurrentState.dRawScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_MICROAMP:
{
m_cstrSecScaleFactor.Format( "%0.2f V/µA", m_mctdCurrentState.dRawScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_NANOAMP:
{
m_cstrSecScaleFactor.Format( "%0.2f V/nA", m_mctdCurrentState.dRawScaleFactor );
break;
}
case MCTG_UNITS_VOLTS_PER_PICOAMP:
{
m_cstrSecScaleFactor.Format( "%0.2f V/pA", m_mctdCurrentState.dRawScaleFactor );
break;
}
default:
{
// invalid units identifier
ASSERT( FALSE );
break;
}
}
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// primary LPF cutoff
///////////////////////////////////////////////////////////////////
if(m_mctdCurrentState.dLPFCutoff >= MCTG_LPF_BYPASS )
{
sprintf(pszTemp, "%.0f Hz", m_mctdCurrentState.dLPFCutoff);
strcat(pszTemp, " ( Bypass )");
}
else
{
sprintf(pszTemp, "%.0f Hz", m_mctdCurrentState.dLPFCutoff);
}
m_cstrPriLPFCutoff = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// secocndary LPF cutoff
///////////////////////////////////////////////////////////////////
if(m_mctdCurrentState.dSecondaryLPFCutoff >= MCTG_LPF_BYPASS )
{
sprintf(pszTemp, "%.0f Hz", m_mctdCurrentState.dSecondaryLPFCutoff);
strcat(pszTemp, " ( Bypass )");
}
else
{
sprintf(pszTemp, "%.0f Hz", m_mctdCurrentState.dSecondaryLPFCutoff);
}
m_cstrSecLPFCutoff = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// membrane capacitance
///////////////////////////////////////////////////////////////////
if(m_mctdCurrentState.dMembraneCap == MCTG_NOMEMBRANECAP)
{
sprintf(pszTemp, "N/A");
}
else
{
sprintf(pszTemp, "%.3f pF", m_mctdCurrentState.dMembraneCap * 1.0e12);
}
m_cstrMembraneCap = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// external command sensitivity
///////////////////////////////////////////////////////////////////
switch( m_mctdCurrentState.uOperatingMode )
{
case MCTG_MODE_VCLAMP:
{
if( m_mctdCurrentState.dExtCmdSens <= 0.0 )
{
sprintf(pszTemp, "OFF");
}
else
{
sprintf(pszTemp, "%.0f mV/V", m_mctdCurrentState.dExtCmdSens * 1.0e3);
}
break;
}
case MCTG_MODE_ICLAMP:
case MCTG_MODE_ICLAMPZERO:
{
if( m_mctdCurrentState.dExtCmdSens <= 0.0 )
{
sprintf(pszTemp, "OFF");
}
else if( m_mctdCurrentState.dExtCmdSens < 1.0e-9 )
{
sprintf(pszTemp, "%.0f pA/V", m_mctdCurrentState.dExtCmdSens * 1.0e12);
}
else
{
sprintf(pszTemp, "%.0f nA/V", m_mctdCurrentState.dExtCmdSens * 1.0e9);
}
break;
}
default:
{
sprintf(pszTemp, "Invalid Operating Mode!");
break;
}
}
m_cstrExtCmdSens = pszTemp;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// application version number
///////////////////////////////////////////////////////////////////
m_cstrAppVer = m_mctdCurrentState.szAppVersion;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// firmware version number
///////////////////////////////////////////////////////////////////
m_cstrFirmwareVer = m_mctdCurrentState.szFirmwareVersion;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// DSP version number
///////////////////////////////////////////////////////////////////
m_cstrDSPVer = m_mctdCurrentState.szDSPVersion;
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
// Serial number number
///////////////////////////////////////////////////////////////////
m_cstrSN = m_mctdCurrentState.szSerialNumber;
///////////////////////////////////////////////////////////////////
UpdateData(FALSE);
}
void LocationDlg::OnRadio( wxCommandEvent &event )
{
TransferDataFromWindow();
UpdateEnabling();
}
void MapServerDlg::OnRadio( wxCommandEvent &event )
{
TransferDataFromWindow();
UpdateEnabling();
}
void InstanceDlg::OnRadio( wxCommandEvent &event )
{
TransferDataFromWindow();
UpdateEnabling();
}
