bool wxRealFormValidator::OnRetrieveValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) )
{
// The item used for viewing the real number: should be a text item.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow || !m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
return false;
wxString value(((wxTextCtrl *)m_propertyWindow)->GetValue());
if (value.Length() == 0)
return false;
float f = (float)wxAtof((const wxChar *)value);
property->GetValue() = f;
return true;
}
bool Shuttle::TransferFloat( const wxString & Name, float & fValue, const float &fDefault )
{
if( mbStoreInClient )
{
fValue = fDefault;
if( ExchangeWithMaster( Name ))
{
if( !mValueString.IsEmpty() )
fValue = wxAtof( mValueString );
}
}
else
{
mValueString = wxString::Format(wxT("%f"),fValue);
return ExchangeWithMaster( Name );
}
return true;
}
void DIALOG_GENERALOPTIONS::OnOkClick( wxCommandEvent& event )
{
EDA_UNITS_T ii;
DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)GetParent()->GetDisplayOptions();
displ_opts->m_DisplayPolarCood = ( m_PolarDisplay->GetSelection() == 0 ) ? false : true;
ii = g_UserUnit;
g_UserUnit = ( m_UnitsSelection->GetSelection() == 0 ) ? INCHES : MILLIMETRES;
if( ii != g_UserUnit )
GetParent()->ReCreateAuxiliaryToolbar();
GetParent()->SetCursorShape( m_CursorShape->GetSelection() );
GetParent()->SetAutoSaveInterval( m_SaveTime->GetValue() * 60 );
GetParent()->SetRotationAngle( wxRound( 10.0 * wxAtof( m_RotationAngle->GetValue() ) ) );
/* Updating the combobox to display the active layer. */
displ_opts->m_MaxLinksShowed = m_MaxShowLinks->GetValue();
g_Drc_On = m_DrcOn->GetValue();
if( m_Board->IsElementVisible(RATSNEST_VISIBLE) != m_ShowGlobalRatsnest->GetValue() )
{
GetParent()->SetElementVisibility(RATSNEST_VISIBLE, m_ShowGlobalRatsnest->GetValue() );
GetParent()->GetCanvas()->Refresh( );
}
displ_opts->m_Show_Module_Ratsnest = m_ShowModuleRatsnest->GetValue();
g_AutoDeleteOldTrack = m_TrackAutodel->GetValue();
g_Segments_45_Only = m_Segments_45_Only_Ctrl->GetValue();
g_Track_45_Only_Allowed = m_Track_45_Only_Ctrl->GetValue();
GetParent()->GetCanvas()->SetEnableZoomNoCenter( m_ZoomNoCenterOpt->GetValue() );
GetParent()->GetCanvas()->SetEnableMiddleButtonPan( m_MiddleButtonPANOpt->GetValue() );
GetParent()->GetCanvas()->SetMiddleButtonPanLimited( m_OptMiddleButtonPanLimited->GetValue() );
GetParent()->GetCanvas()->SetEnableAutoPan( m_AutoPANOpt->GetValue() );
g_TwoSegmentTrackBuild = m_Track_DoubleSegm_Ctrl->GetValue();
g_MagneticPadOption = m_MagneticPadOptCtrl->GetSelection();
g_MagneticTrackOption = m_MagneticTrackOptCtrl->GetSelection();
g_UseOldZoneFillingAlgo = m_UseOldZoneFillingAlgo->GetValue();
g_DumpZonesWhenFilling = m_DumpZonesWhenFilling->GetValue();
EndModal( wxID_OK );
}
void ModelControl::OnEnter(wxCommandEvent &event)
{
if (!init || !model)
return;
int id = event.GetId();
model->pos.x = wxAtof(txtX->GetValue());
model->pos.y = wxAtof(txtY->GetValue());
model->pos.z = wxAtof(txtZ->GetValue());
model->rot.x = wxAtof(rotX->GetValue());
model->rot.y = wxAtof(rotY->GetValue());
model->rot.z = wxAtof(rotZ->GetValue());
att->scale = wxAtof(txtsize->GetValue());
if (event.GetId() == ID_MODEL_SIZE){
scale->SetValue(wxAtoi(txtsize->GetValue())*100);
}
}
bool Shuttle::TransferDouble( const wxString & Name, double & dValue, const double &dDefault )
{
if( mbStoreInClient )
{
dValue = dDefault;
if( ExchangeWithMaster( Name ))
{
if( !mValueString.IsEmpty() )
dValue = wxAtof( mValueString );
}
}
else
{
//%f is format string for double
mValueString = wxString::Format(wxT("%f"),dValue);
return ExchangeWithMaster( Name );
}
return true;
}
void CatheterGrid::OnGridCellChanging(wxGridEvent& e)
{
// called when edited cell loses focus
// last value: GetCellValue(row, col)
// pending value: e.GetString()
int row = e.GetRow();
int col = e.GetCol();
switch (col)
{
case CHANNEL_COL:
// setGridRowChannel(row, wxAtoi(e.GetString()));
setGridRowChannel(row, e.GetString());
break;
case CURRENT_COL:
setGridRowcurrentMilliAmp(row, wxAtof(e.GetString()));
break;
case DIRECTION_COL:
setGridRowDirection(row, (wxStrcmp(DIRPOSSTR, e.GetString()) ? DIR_NEG : DIR_POS));
break;
case DELAY_COL:
setGridRowDelayMS(row, wxAtoi(e.GetString()));
break;
}
if (row == cmdCount && isGridRowComplete(row)) {
cmdCount++;
if (cmdCount < GetNumberRows())
setRowReadOnly(cmdCount, false);
else
addGridRow(false);
// wxMessageBox(wxString::Format("completed command %d", cmdCount));
}
e.Skip();
}
double CatheterCmdGrid::getCommandCurrentMA(int cmd_num) const {
return wxAtof(GetCellValue(cmd_num, CURRENT_COL));
}
// Called to transfer data from the window
bool wxGenericValidator::TransferFromWindow(void)
{
if ( !m_validatorWindow )
return false;
// BOOL CONTROLS **************************************
#if wxUSE_CHECKBOX
if (wxDynamicCast(m_validatorWindow, wxCheckBox))
{
wxCheckBox* pControl = (wxCheckBox*) m_validatorWindow;
if (m_pBool)
{
*m_pBool = pControl->GetValue() ;
return true;
}
} else
#endif
#if wxUSE_RADIOBTN
if (wxDynamicCast(m_validatorWindow, wxRadioButton))
{
wxRadioButton* pControl = (wxRadioButton*) m_validatorWindow;
if (m_pBool)
{
*m_pBool = pControl->GetValue() ;
return true;
}
} else
#endif
#if wxUSE_TOGGLEBTN
if (wxDynamicCast(m_validatorWindow, wxToggleButton))
{
wxToggleButton *pControl = (wxToggleButton *) m_validatorWindow;
if (m_pBool)
{
*m_pBool = pControl->GetValue() ;
return true;
}
} else
#if (defined(__WXMAC__) || defined(__WXMSW__) || defined(__WXGTK20__)) && !defined(__WXUNIVERSAL__)
if (wxDynamicCast(m_validatorWindow, wxBitmapToggleButton))
{
wxBitmapToggleButton *pControl = (wxBitmapToggleButton *) m_validatorWindow;
if (m_pBool)
{
*m_pBool = pControl->GetValue() ;
return true;
}
} else
#endif
#endif
// INT CONTROLS ***************************************
#if wxUSE_GAUGE
if (wxDynamicCast(m_validatorWindow, wxGauge))
{
wxGauge* pControl = (wxGauge*) m_validatorWindow;
if (m_pInt)
{
*m_pInt = pControl->GetValue() ;
return true;
}
} else
#endif
#if wxUSE_RADIOBOX
if (wxDynamicCast(m_validatorWindow, wxRadioBox))
{
wxRadioBox* pControl = (wxRadioBox*) m_validatorWindow;
if (m_pInt)
{
*m_pInt = pControl->GetSelection() ;
return true;
}
} else
#endif
#if wxUSE_SCROLLBAR
if (wxDynamicCast(m_validatorWindow, wxScrollBar))
{
wxScrollBar* pControl = (wxScrollBar*) m_validatorWindow;
if (m_pInt)
{
*m_pInt = pControl->GetThumbPosition() ;
return true;
}
} else
#endif
#if wxUSE_SPINCTRL && !defined(__WXMOTIF__)
if (wxDynamicCast(m_validatorWindow, wxSpinCtrl))
{
wxSpinCtrl* pControl = (wxSpinCtrl*) m_validatorWindow;
if (m_pInt)
{
*m_pInt=pControl->GetValue();
return true;
}
} else
#endif
#if wxUSE_SPINBTN
if (wxDynamicCast(m_validatorWindow, wxSpinButton))
{
wxSpinButton* pControl = (wxSpinButton*) m_validatorWindow;
if (m_pInt)
{
*m_pInt = pControl->GetValue() ;
return true;
}
} else
#endif
#if wxUSE_SLIDER
if (wxDynamicCast(m_validatorWindow, wxSlider))
{
wxSlider* pControl = (wxSlider*) m_validatorWindow;
if (m_pInt)
{
*m_pInt = pControl->GetValue() ;
return true;
}
} else
#endif
// DATE TIME CONTROLS ************************************
#if 0 // wxUSE_DATEPICKCTRL -- temporary fix for shared build linking
if (wxDynamicCast(m_validatorWindow, wxDatePickerCtrl))
{
wxDatePickerCtrl* pControl = (wxDatePickerCtrl*) m_validatorWindow;
if (m_pDateTime)
{
*m_pDateTime = pControl->GetValue() ;
return true;
}
} else
#endif
// STRING CONTROLS ************************************
#if wxUSE_BUTTON
if (wxDynamicCast(m_validatorWindow, wxButton))
{
wxButton* pControl = (wxButton*) m_validatorWindow;
if (m_pString)
{
*m_pString = pControl->GetLabel() ;
return true;
}
} else
#endif
#if wxUSE_COMBOBOX
if (wxDynamicCast(m_validatorWindow, wxComboBox))
{
wxComboBox* pControl = (wxComboBox*) m_validatorWindow;
if (m_pInt)
{
*m_pInt = pControl->GetSelection() ;
return true;
}
else if (m_pString)
{
if (m_validatorWindow->GetWindowStyle() & wxCB_READONLY)
*m_pString = pControl->GetStringSelection();
else
*m_pString = pControl->GetValue();
return true;
}
} else
#endif
#if wxUSE_CHOICE
if (wxDynamicCast(m_validatorWindow, wxChoice))
{
wxChoice* pControl = (wxChoice*) m_validatorWindow;
if (m_pInt)
{
*m_pInt = pControl->GetSelection() ;
return true;
}
else if (m_pString)
{
*m_pString = pControl->GetStringSelection();
return true;
}
} else
#endif
#if wxUSE_STATTEXT
if (wxDynamicCast(m_validatorWindow, wxStaticText))
{
wxStaticText* pControl = (wxStaticText*) m_validatorWindow;
if (m_pString)
{
*m_pString = pControl->GetLabel() ;
return true;
}
} else
#endif
#if wxUSE_TEXTCTRL
if (wxDynamicCast(m_validatorWindow, wxTextCtrl))
{
wxTextCtrl* pControl = (wxTextCtrl*) m_validatorWindow;
if (m_pString)
{
*m_pString = pControl->GetValue() ;
return true;
}
else if (m_pInt)
{
*m_pInt = wxAtoi(pControl->GetValue());
return true;
}
else if (m_pFileName)
{
m_pFileName->Assign(pControl->GetValue());
return true;
}
else if (m_pFloat)
{
*m_pFloat = (float)wxAtof(pControl->GetValue());
return true;
}
else if (m_pDouble)
{
*m_pDouble = wxAtof(pControl->GetValue());
return true;
}
} else
#endif
// ARRAY CONTROLS *************************************
#if wxUSE_CHECKLISTBOX
// NOTE: wxCheckListBox isa wxListBox, so wxCheckListBox MUST come first:
if (wxDynamicCast(m_validatorWindow, wxCheckListBox))
{
wxCheckListBox* pControl = (wxCheckListBox*) m_validatorWindow;
if (m_pArrayInt)
{
// clear our array
m_pArrayInt->Clear();
// add each selected item to our array
size_t i,
count = pControl->GetCount();
for ( i = 0; i < count; i++ )
{
if (pControl->IsChecked(i))
m_pArrayInt->Add(i);
}
return true;
}
else
return false;
} else
#endif
#if wxUSE_LISTBOX
if (wxDynamicCast(m_validatorWindow, wxListBox))
{
wxListBox* pControl = (wxListBox*) m_validatorWindow;
if (m_pArrayInt)
{
// clear our array
m_pArrayInt->Clear();
// add each selected item to our array
size_t i,
count = pControl->GetCount();
for ( i = 0; i < count; i++ )
{
if (pControl->IsSelected(i))
m_pArrayInt->Add(i);
}
return true;
}
} else
#endif
// unrecognized control, or bad pointer
return false;
return false;
}
void StateEffect::RenderState(RenderBuffer &buffer,
SequenceElements *elements, const std::string &faceDefinition,
const std::string& Phoneme, const std::string &trackName, const std::string& mode, const std::string& colourmode)
{
if (buffer.needToInit) {
buffer.needToInit = false;
elements->AddRenderDependency(trackName, buffer.cur_model);
if (buffer.isTransformed)
{
log4cpp::Category &logger_base = log4cpp::Category::getInstance(std::string("log_base"));
logger_base.warn("State effect starting at %dms until %dms on model %s has a transformed buffer. This may not work as expected.", buffer.curEffStartPer * buffer.frameTimeInMs, buffer.curEffEndPer * buffer.frameTimeInMs, (const char *)buffer.cur_model.c_str());
}
}
Element *track = elements->GetElement(trackName);
std::recursive_mutex tmpLock;
std::recursive_mutex *lock = &tmpLock;
if (track != nullptr) {
lock = &track->GetChangeLock();
}
std::unique_lock<std::recursive_mutex> locker(*lock);
if (buffer.cur_model == "") {
return;
}
Model* model_info = buffer.frame->AllModels[buffer.cur_model];
if (model_info == nullptr) {
return;
}
std::string definition = faceDefinition;
bool found = true;
std::map<std::string, std::map<std::string, std::string> >::iterator it = model_info->stateInfo.find(definition);
if (it == model_info->stateInfo.end()) {
//not found
found = false;
}
if (!found) {
if ("Coro" == definition && model_info->stateInfo.find("SingleNode") != model_info->stateInfo.end()) {
definition = "SingleNode";
found = true;
} else if ("SingleNode" == definition && model_info->stateInfo.find("Coro") != model_info->stateInfo.end()) {
definition = "Coro";
found = true;
}
}
if (definition == "")
{
return;
}
std::string modelType = found ? model_info->stateInfo[definition]["Type"] : definition;
if (modelType == "") {
modelType = definition;
}
int type = 1;
if ("SingleNode" == modelType) {
type = 0;
} else if ("NodeRange" == modelType) {
type = 1;
}
std::string tstates = Phoneme;
int intervalnumber = 0;
//GET label from timing track
int startms = -1;
int endms = -1;
int posms = -1;
if (tstates == "") {
// if we dont have a track then exit
if (track == NULL)
{
return;
}
EffectLayer *layer = track->GetEffectLayer(0);
std::unique_lock<std::recursive_mutex> locker(layer->GetLock());
int time = buffer.curPeriod * buffer.frameTimeInMs + 1;
posms = buffer.curPeriod * buffer.frameTimeInMs;
Effect *ef = layer->GetEffectByTime(time);
if (ef == nullptr) {
tstates = "";
}
else {
startms = ef->GetStartTimeMS();
endms = ef->GetEndTimeMS();
tstates = ef->GetEffectName();
}
ef = layer->GetEffectByTime(buffer.curEffStartPer * buffer.frameTimeInMs + 1);
while (ef != NULL && ef->GetStartTimeMS() <= time)
{
intervalnumber++;
int endtime = ef->GetEndTimeMS();
ef = layer->GetEffectByTime(endtime + 1);
if (ef == NULL)
{
ef = layer->GetEffectAfterTime(endtime + 1);
}
}
}
std::vector<std::string> sstates;
if (mode == "Default" || startms == -1)
{
wxString ss = wxString(tstates);
wxStringTokenizer tkz(ss, wxT(" ,;:"));
while (tkz.HasMoreTokens())
{
wxString token = tkz.GetNextToken();
sstates.push_back(token.Lower().ToStdString());
}
}
else if (mode == "Countdown")
{
// tstates should contain the starting number
int val = wxAtoi(tstates);
val = val * 1000;
int subtracttime = (posms - startms);
val = val - subtracttime;
val = val / 1000;
int v = val;
bool force = false;
if ((v / 1000) * 1000 > 0)
{
sstates.push_back(wxString::Format("%d", (v / 1000) * 1000).ToStdString());
force = true;
}
v = v - (v / 1000) * 1000;
if ((v / 100) * 100 > 0)
{
sstates.push_back(wxString::Format("%d", (v / 100) * 100).ToStdString());
force = true;
}
else
{
if (force)
{
sstates.push_back("000");
}
}
v = v - (v / 100) * 100;
if ((v / 10) * 10 > 0)
{
sstates.push_back(wxString::Format("%d", (v / 10) * 10).ToStdString());
}
else
{
if (force)
{
sstates.push_back("00");
}
}
v = v - (v / 10) * 10;
sstates.push_back(wxString::Format("%d", v).ToStdString());
}
else if (mode == "Time Countdown")
{
wxDateTime dt;
dt.ParseFormat(tstates.c_str(), "%H:%M:%S");
if (!dt.IsValid())
{
dt.ParseFormat(tstates.c_str(), "%M:%S");
}
if (dt.IsValid())
{
dt.Subtract(wxTimeSpan(0, 0, 0, (buffer.curPeriod - buffer.curEffStartPer) * buffer.frameTimeInMs));
int m = dt.GetMinute();
if ((m / 10) * 1000 > 0)
{
sstates.push_back(wxString::Format("%d", (m / 10) * 1000).ToStdString());
}
else
{
sstates.push_back("0000");
}
m = m - (m / 10) * 10;
if (m * 100 > 0)
{
sstates.push_back(wxString::Format("%d", m * 100).ToStdString());
}
else
{
sstates.push_back("000");
}
int s = dt.GetSecond();
if ((s / 10) * 10 > 0)
{
sstates.push_back(wxString::Format("%d", (s / 10) * 10).ToStdString());
}
else
{
sstates.push_back("00");
}
s = s - (s / 10) * 10;
sstates.push_back(wxString::Format("%d", s).ToStdString());
}
sstates.push_back("colon");
}
else if (mode == "Number") // used for FM frequencies
{
double f = wxAtof(tstates);
sstates.push_back("dot");
double f2 = f - int(f);
f2 = (int)(f2 * 10 + 0.5);
sstates.push_back(wxString::Format("%d", (int)f2).ToStdString());
int v = f;
bool force = false;
if ((v / 100) * 1000 > 0)
{
sstates.push_back(wxString::Format("%d", (v / 100) * 1000).ToStdString());
force = true;
}
v = v - (v / 100) * 100;
if ((v / 10) * 100 > 0)
{
sstates.push_back(wxString::Format("%d", (v / 10) * 100).ToStdString());
}
else
{
if (force)
{
sstates.push_back("000");
}
}
v = v - (v / 10) * 10;
if (v * 10 > 0)
{
sstates.push_back(wxString::Format("%d", v * 10).ToStdString());
}
else
{
sstates.push_back("00");
}
}
else if (mode == "Iterate")
{
float progressthroughtimeinterval = ((float)posms - (float)startms) / ((float)endms - (float)startms);
std::vector<std::string> tmpstates;
wxString ss = wxString(tstates);
wxStringTokenizer tkz(ss, wxT(" ,;:"));
while (tkz.HasMoreTokens())
{
wxString token = tkz.GetNextToken();
tmpstates.push_back(token.Lower().ToStdString());
}
int which = tmpstates.size() * progressthroughtimeinterval;
if (which < sstates.size())
{
sstates.push_back(tmpstates[which]);
}
}
bool customColor = found ? model_info->stateInfo[definition]["CustomColors"] == "1" : false;
// process each token
for (size_t i = 0; i < sstates.size(); i++)
{
// get the channels
std::string statename = FindState(model_info->stateInfo[definition], sstates[i]);
std::string channels = model_info->stateInfo[definition][statename];
if (statename != "" && channels != "")
{
xlColor color;
if (colourmode == "Graduate")
{
buffer.GetMultiColorBlend(buffer.GetEffectTimeIntervalPosition(), false, color);
}
else if (colourmode == "Cycle")
{
buffer.palette.GetColor((intervalnumber - 1) % buffer.GetColorCount(), color);
}
else
{
// allocate
int statenum = wxAtoi(statename.substr(1));
buffer.palette.GetColor((statenum - 1) % buffer.GetColorCount(), color);
}
if (customColor) {
std::string cname = model_info->stateInfo[definition][statename + "-Color"];
if (cname == "") {
color = xlWHITE;
}
else {
color = xlColor(cname);
}
}
wxStringTokenizer wtkz(channels, ",");
while (wtkz.HasMoreTokens())
{
wxString valstr = wtkz.GetNextToken();
if (type == 0) {
for (size_t n = 0; n < model_info->GetNodeCount(); n++) {
wxString nn = model_info->GetNodeName(n, true);
if (nn == valstr) {
for (auto a = buffer.Nodes[n]->Coords.begin() ; a != buffer.Nodes[n]->Coords.end(); a++) {
buffer.SetPixel(a->bufX, a->bufY, color);
}
}
}
}
else if (type == 1) {
int start, end;
if (valstr.Contains("-")) {
int idx = valstr.Index('-');
start = wxAtoi(valstr.Left(idx));
end = wxAtoi(valstr.Right(valstr.size() - idx - 1));
}
else {
start = end = wxAtoi(valstr);
}
if (start > end) {
start = end;
}
start--;
end--;
for (int n = start; n <= end; n++) {
if (n < buffer.Nodes.size()) {
for (auto a = buffer.Nodes[n]->Coords.begin() ; a != buffer.Nodes[n]->Coords.end(); a++) {
buffer.SetPixel(a->bufX, a->bufY, color);
}
}
}
}
}
}
}
}
double CatheterGrid::getGridRowcurrentMilliAmp(int row) {
return wxAtof(GetCellValue(wxGridCellCoords(row, CURRENT_COL)));
}
static double GetHtmlDoubleValue(const wxString& value)
{
return wxAtof(value);
}
