bool WaveTrack::HandleXMLTag(const char *tag, const char **attrs)
{
if (!strcmp(tag, "wavetrack")) {
double dblValue;
long nValue;
while(*attrs) {
const char *attr = *attrs++;
const char *value = *attrs++;
if (!value)
break;
const wxString strValue = value;
if (!strcmp(attr, "rate"))
{
if (!XMLValueChecker::IsGoodString(strValue) ||
!Internat::CompatibleToDouble(strValue, &dblValue) ||
(dblValue < 100.0) || (dblValue > 100000.0)) // same bounds as ImportRawDialog::OnOK
return false;
mRate = dblValue;
}
else if (!strcmp(attr, "offset") &&
XMLValueChecker::IsGoodString(strValue) &&
Internat::CompatibleToDouble(strValue, &dblValue))
{
mOffset = dblValue;
mEnvelope->SetOffset(mOffset);
}
else if (!strcmp(attr, "gain") &&
XMLValueChecker::IsGoodString(strValue) &&
Internat::CompatibleToDouble(strValue, &dblValue))
mGain = dblValue;
else if (!strcmp(attr, "pan") &&
XMLValueChecker::IsGoodString(strValue) &&
Internat::CompatibleToDouble(strValue, &dblValue) &&
(dblValue >= -1.0) && (dblValue <= 1.0))
mPan = dblValue;
else if (!strcmp(attr, "name") && XMLValueChecker::IsGoodString(strValue))
mName = strValue;
else if (!strcmp(attr, "channel"))
{
if (!XMLValueChecker::IsGoodInt(strValue) || !strValue.ToLong(&nValue) ||
!XMLValueChecker::IsValidChannel(nValue))
return false;
mChannel = nValue;
}
else if (!strcmp(attr, "linked") &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
mLinked = (nValue != 0);
} // while
return true;
}
return false;
}
bool NoteTrack::HandleXMLTag(const wxChar *tag, const wxChar **attrs)
{
if (!wxStrcmp(tag, wxT("notetrack"))) {
while (*attrs) {
const wxChar *attr = *attrs++;
const wxChar *value = *attrs++;
if (!value)
break;
const wxString strValue = value;
long nValue;
double dblValue;
if (!wxStrcmp(attr, wxT("name")) && XMLValueChecker::IsGoodString(strValue))
mName = strValue;
else if (!wxStrcmp(attr, wxT("offset")) &&
XMLValueChecker::IsGoodString(strValue) &&
Internat::CompatibleToDouble(strValue, &dblValue))
SetOffset(dblValue);
else if (!wxStrcmp(attr, wxT("visiblechannels"))) {
if (!XMLValueChecker::IsGoodInt(strValue) ||
!strValue.ToLong(&nValue) ||
!XMLValueChecker::IsValidVisibleChannels(nValue))
return false;
mVisibleChannels = nValue;
}
else if (!wxStrcmp(attr, wxT("height")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
mHeight = nValue;
else if (!wxStrcmp(attr, wxT("minimized")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
mMinimized = (nValue != 0);
else if (!wxStrcmp(attr, wxT("isSelected")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
this->SetSelected(nValue != 0);
#ifdef EXPERIMENTAL_MIDI_OUT
else if (!wxStrcmp(attr, wxT("velocity")) &&
XMLValueChecker::IsGoodString(strValue) &&
Internat::CompatibleToDouble(strValue, &dblValue))
mGain = (float) dblValue;
#endif
else if (!wxStrcmp(attr, wxT("bottomnote")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
SetBottomNote(nValue);
else if (!wxStrcmp(attr, wxT("data"))) {
std::string s(strValue.mb_str(wxConvUTF8));
std::istringstream data(s);
mSeq = new Alg_seq(data, false);
}
} // while
return true;
}
return false;
}
bool TimeTrack::HandleXMLTag(const wxChar *tag, const wxChar **attrs)
{
if (!wxStrcmp(tag, wxT("timetrack"))) {
mRescaleXMLValues = true; // will be set to false if upper/lower is found
long nValue;
while(*attrs) {
const wxChar *attr = *attrs++;
const wxChar *value = *attrs++;
if (!value)
break;
const wxString strValue = value;
if (!wxStrcmp(attr, wxT("name")) && XMLValueChecker::IsGoodString(strValue))
mName = strValue;
else if (!wxStrcmp(attr, wxT("height")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
mHeight = nValue;
else if (!wxStrcmp(attr, wxT("minimized")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
mMinimized = (nValue != 0);
else if (!wxStrcmp(attr, wxT("rangelower")))
{
mRangeLower = Internat::CompatibleToDouble(value);
mRescaleXMLValues = false;
}
else if (!wxStrcmp(attr, wxT("rangeupper")))
{
mRangeUpper = Internat::CompatibleToDouble(value);
mRescaleXMLValues = false;
}
else if (!wxStrcmp(attr, wxT("displaylog")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
{
SetDisplayLog(nValue != 0);
//TODO-MB: This causes a graphical glitch, TrackPanel should probably be Refresh()ed after loading.
// I don't know where to do this though.
}
else if (!wxStrcmp(attr, wxT("interpolatelog")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
{
SetInterpolateLog(nValue != 0);
}
} // while
if(mRescaleXMLValues)
mEnvelope->SetRange(0.0, 1.0); // this will be restored to the actual range later
return true;
}
return false;
}
/* compare Strings that contains int/long numbers */
static int CompareLongString(const wxString& first,const wxString& second) {
long lFirst;
long lSecond;
first.ToLong(&lFirst);
second.ToLong(&lSecond);
if(lFirst < lSecond) {
return reverseCompareOrder ? 1 : -1 ;
}
if(lSecond < lFirst) {
return reverseCompareOrder ? -1 : 1 ;
}
return 0;
}
/////////////////////////////////////////////////////////
// Resets a value with a string, preserving current type
void VariableData::ResetWith(wxString value) {
switch (type) {
case VARDATA_INT: {
long temp = 0;
value.ToLong(&temp);
SetInt(temp);
break;
}
case VARDATA_FLOAT: {
double temp = 0;
value.ToDouble(&temp);
SetFloat(temp);
break;
}
case VARDATA_BOOL:
if (value == _T("1")) SetBool(true);
else SetBool(false);
break;
case VARDATA_COLOUR: {
long r=0,g=0,b=0;
value.Mid(1,2).ToLong(&r,16);
value.Mid(3,2).ToLong(&g,16);
value.Mid(5,2).ToLong(&b,16);
SetColour(wxColour(r,g,b));
break;
}
default:
SetText(value);
break;
}
}
bool COptions::SetOption(unsigned int nID, wxString value)
{
if (nID >= OPTIONS_NUM)
return false;
if (options[nID].type != string)
{
long tmp;
if (!value.ToLong(&tmp))
return false;
return SetOption(nID, tmp);
}
Validate(nID, value);
m_optionsCache[nID].cached = true;
m_optionsCache[nID].strValue = value;
if (m_pXmlFile && !options[nID].internal)
{
SetXmlValue(nID, value);
if (!m_save_timer.IsRunning())
m_save_timer.Start(15000, true);
}
return true;
}
OCP_DataStreamInput_Thread::OCP_DataStreamInput_Thread(DataStream *Launcher,
wxEvtHandler *MessageTarget,
const wxString& PortName,
const wxString& strBaudRate,
dsPortType io_select
)
{
m_launcher = Launcher; // This thread's immediate "parent"
m_pMessageTarget = MessageTarget;
m_PortName = PortName;
m_FullPortName = _T("Serial:") + PortName;
m_io_select = io_select;
rx_buffer = new char[DS_RX_BUFFER_SIZE + 1];
temp_buf = new char[DS_RX_BUFFER_SIZE + 1];
put_ptr = rx_buffer; // local circular queue
tak_ptr = rx_buffer;
m_baud = 4800; // default
long lbaud;
if(strBaudRate.ToLong(&lbaud))
m_baud = (int)lbaud;
Create();
}
bool COptions::SetOption(unsigned int nID, wxString value)
{
if (nID >= OPTIONS_NUM)
return false;
if (options[nID].type != string)
{
long tmp;
if (!value.ToLong(&tmp))
return false;
return SetOption(nID, tmp);
}
Validate(nID, value);
if (m_optionsCache[nID].strValue == value)
{
// Nothing to do
return true;
}
m_optionsCache[nID].strValue = value;
if (m_pXmlFile && options[nID].flags == normal)
{
SetXmlValue(nID, value);
if (!m_save_timer.IsRunning())
m_save_timer.Start(15000, true);
}
COptionChangeEventHandler::DoNotify(nID);
return true;
}
long wxString_ToLong(wxString const &str)
{
long value;
if(!str.ToLong(&value))
return -1;
return value;
}
void tcBitfieldControl::SetValue(const wxString& s)
{
long val = 0;
if (s.ToLong(&val))
{
for (size_t n=0; n<checkBoxes.size(); n++)
{
bool state_n = (val & checkValues[n]) != 0;
checkBoxes[n]->SetValue(state_n);
checkBoxes[n]->Refresh();
}
tcEditControl::SetValue(s);
}
else
{
wxASSERT(false); // not an integer
for (size_t n=0; n<checkBoxes.size(); n++)
{
checkBoxes[n]->SetValue(false);
checkBoxes[n]->Refresh();
}
tcEditControl::SetValue("0");
}
}
bool Envelope::HandleXMLTag(const wxChar *tag, const wxChar **attrs)
{
// Return unless it's the envelope tag.
if (wxStrcmp(tag, wxT("envelope")))
return false;
int numPoints = 0;
long nValue = -1;
while (*attrs) {
const wxChar *attr = *attrs++;
const wxChar *value = *attrs++;
if (!value)
break;
const wxString strValue = value;
if( !wxStrcmp(attr, wxT("numpoints")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
numPoints = nValue;
}
if (numPoints < 0)
return false;
WX_CLEAR_ARRAY(mEnv);
mEnv.Alloc(numPoints);
return true;
}
/// Constructs a ODPCMAliasBlockFile from the xml output of WriteXML.
/// Does not schedule the ODPCMAliasBlockFile for OD loading. Client code must do this.
// BuildFromXML methods should always return a BlockFile, not NULL,
// even if the result is flawed (e.g., refers to nonexistent file),
// as testing will be done in DirManager::ProjectFSCK().
BlockFilePtr ODPCMAliasBlockFile::BuildFromXML(DirManager &dm, const wxChar **attrs)
{
wxFileNameWrapper summaryFileName;
wxFileNameWrapper aliasFileName;
sampleCount aliasStart = 0;
size_t aliasLen = 0;
int aliasChannel=0;
long nValue;
long long nnValue;
while(*attrs)
{
const wxChar *attr = *attrs++;
const wxChar *value = *attrs++;
if (!value)
break;
const wxString strValue = value;
if (!wxStricmp(attr, wxT("summaryfile")) &&
// Can't use XMLValueChecker::IsGoodFileName here, but do part of its test.
XMLValueChecker::IsGoodFileString(strValue) &&
(strValue.Length() + 1 + dm.GetProjectDataDir().Length() <= PLATFORM_MAX_PATH))
{
if (!dm.AssignFile(summaryFileName, strValue, false))
// Make sure summaryFileName is back to uninitialized state so we can detect problem later.
summaryFileName.Clear();
}
else if( !wxStricmp(attr, wxT("aliasfile")) )
{
if (XMLValueChecker::IsGoodPathName(strValue))
aliasFileName.Assign(strValue);
else if (XMLValueChecker::IsGoodFileName(strValue, dm.GetProjectDataDir()))
// Allow fallback of looking for the file name, located in the data directory.
aliasFileName.Assign(dm.GetProjectDataDir(), strValue);
else if (XMLValueChecker::IsGoodPathString(strValue))
// If the aliased file is missing, we failed XMLValueChecker::IsGoodPathName()
// and XMLValueChecker::IsGoodFileName, because both do existence tests,
// but we want to keep the reference to the missing file because it's a good path string.
aliasFileName.Assign(strValue);
}
else if ( !wxStricmp(attr, wxT("aliasstart")) )
{
if (XMLValueChecker::IsGoodInt64(strValue) &&
strValue.ToLongLong(&nnValue) && (nnValue >= 0))
aliasStart = nnValue;
}
else if (XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
{ // integer parameters
if (!wxStricmp(attr, wxT("aliaslen")) && (nValue >= 0))
aliasLen = nValue;
else if (!wxStricmp(attr, wxT("aliaschannel")) && XMLValueChecker::IsValidChannel(aliasChannel))
aliasChannel = nValue;
}
}
return make_blockfile<ODPCMAliasBlockFile>
(std::move(summaryFileName), std::move(aliasFileName),
aliasStart, aliasLen, aliasChannel, 0, 0, 0, false);
}
float wxNativeFontInfo::GetFractionalPointSize() const
{
const wxString s = GetXFontComponent(wxXLFD_POINTSIZE);
// return -1 to indicate that the size is unknown
long l;
return s.ToLong(&l) ? l : -1;
}
long GetSpeedFromString(wxString label){
long temp;
label.Replace(_("kB/s"),wxT(""),TRUE);
label.Trim(FALSE);
label.Trim(TRUE);
label.ToLong(&temp);
return temp;
}
void UserSettings::AssignSettingValue(int& setting, wxString value, int defaultValue) {
long tempValue;
if(!value.ToLong(&tempValue)) {
setting = defaultValue;
} else {
setting = (int)tempValue;
}
}
// Used for sorting work when idle values
static int CompareWorkWhenIdle(const wxString& strFirst, const wxString& strSecond) {
long lFirstValue;
long lSecondValue;
// Convert to numbers
strFirst.ToLong(&lFirstValue);
strSecond.ToLong(&lSecondValue);
// Is lFirstValue larger than lSecondValue?
if (lFirstValue > lSecondValue) return 1;
// Is lFirstValue less than lSecondValue?
if (lFirstValue < lSecondValue) return -1;
// they must be equal
return 0;
}
// Return true iff the attribute is recognized.
bool PlayableTrack::HandleXMLAttribute(const wxChar *attr, const wxChar *value)
{
const wxString strValue{ value };
long nValue;
if (!wxStrcmp(attr, wxT("mute")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue)) {
mMute = (nValue != 0);
return true;
}
else if (!wxStrcmp(attr, wxT("solo")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue)) {
mSolo = (nValue != 0);
return true;
}
return AudioTrack::HandleXMLAttribute(attr, value);
}
bool xsBoolPropIO::FromString(const wxString& value)
{
long num = 0;
if(!value.IsEmpty())
{
value.ToLong(&num);
}
return (num == 1);
}
int xsIntPropIO::FromString(const wxString& value)
{
long num = 0;
if(!value.IsEmpty())
{
value.ToLong(&num);
}
return (int)num;
}
long xsLongPropIO::FromString(const wxString& value)
{
long num = 0;
if(!value.IsEmpty())
{
value.ToLong(&num);
}
return num;
}
wsArgInfo::wsArgInfo( const wxString &argName, const wxString &argType, const wxString &argMode, const wxString &argTypeOid)
: m_name( argName.Strip( wxString::both )),
m_type( argType.Strip( wxString::both )),
m_mode( argMode == wxT( "" ) ? wxT( "i" ) : argMode.Strip( wxString::both )),
m_value()
{
long oid;
argTypeOid.ToLong(&oid);
m_typeOid = (Oid)oid;
}
virtual void UpdateUI(const wxString& key, const wxString& value)
{
if(swRoads == key)
{
value.ToLong(&sRoads);
}
else if(swSettlements == key)
{
value.ToLong(&sSettlements);
}
else if(swCities == key)
{
value.ToLong(&sCities);
}
else
{
wxASSERT(false);
}
}
bool TimeTrack::HandleXMLTag(const wxChar *tag, const wxChar **attrs)
{
if (!wxStrcmp(tag, wxT("timetrack"))) {
double dblValue;
long nValue;
while(*attrs) {
const wxChar *attr = *attrs++;
const wxChar *value = *attrs++;
if (!value)
break;
const wxString strValue = value;
if (!wxStrcmp(attr, wxT("offset")))
{
if (!XMLValueChecker::IsGoodString(strValue) ||
!Internat::CompatibleToDouble(strValue, &dblValue))
return false;
mOffset = dblValue;
mEnvelope->SetOffset(mOffset);
}
else if (!wxStrcmp(attr, wxT("name")) && XMLValueChecker::IsGoodString(strValue))
mName = strValue;
else if (!wxStrcmp(attr, wxT("channel")))
{
if (!XMLValueChecker::IsGoodInt(strValue) || !strValue.ToLong(&nValue) ||
!XMLValueChecker::IsValidChannel(nValue))
return false;
mChannel = nValue;
}
else if (!wxStrcmp(attr, wxT("height")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
mHeight = nValue;
else if (!wxStrcmp(attr, wxT("minimized")) &&
XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
mMinimized = (nValue != 0);
} // while
return true;
}
return false;
}
void SoundingGridTable::SetValue(int x, int y, const wxString& str)
{
long value;
if(str.ToLong(&value))
{
if(x < rows && x > -1 && y < cols && y > -1)
{
data[y][x]=(int)value;
}
}
}
bool wxsCorrector::FixIdName(wxString& Id)
{
Id.Trim(true);
Id.Trim(false);
long Tmp;
if ( Id.ToLong(&Tmp,10) ) return false;
// We'll use FixVarName's routines to correct identifier
return FixVarName(Id);
}
bool cmdListCtrl::onDelete(const wxString& item)
{
if (g_config && item.IsNumber())
{
long id;
item.ToLong(&id);
if (id >= 0 && g_config->DeleteCmd(id))
return true;
}
return false;
}
// BuildFromXML methods should always return a BlockFile, not NULL,
// even if the result is flawed (e.g., refers to nonexistent file),
// as testing will be done in DirManager::ProjectFSCK().
BlockFile *LegacyAliasBlockFile::BuildFromXML(wxString projDir, const wxChar **attrs)
{
wxFileName summaryFileName;
wxFileName aliasFileName;
int aliasStart=0, aliasLen=0, aliasChannel=0;
int summaryLen=0;
bool noRMS = false;
long nValue;
while(*attrs)
{
const wxChar *attr = *attrs++;
const wxChar *value = *attrs++;
if (!value)
break;
const wxString strValue = value;
if (!wxStricmp(attr, wxT("name")) && XMLValueChecker::IsGoodFileName(strValue, projDir))
//v Should this be
// dm.AssignFile(summaryFileName, strValue, false);
// as in PCMAliasBlockFile::BuildFromXML? Test with an old project.
summaryFileName.Assign(projDir, strValue, wxT(""));
else if ( !wxStricmp(attr, wxT("aliaspath")) )
{
if (XMLValueChecker::IsGoodPathName(strValue))
aliasFileName.Assign(strValue);
else if (XMLValueChecker::IsGoodFileName(strValue, projDir))
// Allow fallback of looking for the file name, located in the data directory.
aliasFileName.Assign(projDir, strValue);
else if (XMLValueChecker::IsGoodPathString(strValue))
// If the aliased file is missing, we failed XMLValueChecker::IsGoodPathName()
// and XMLValueChecker::IsGoodFileName, because both do existence tests,
// but we want to keep the reference to the missing file because it's a good path string.
aliasFileName.Assign(strValue);
}
else if (XMLValueChecker::IsGoodInt(strValue) && strValue.ToLong(&nValue))
{ // integer parameters
if (!wxStricmp(attr, wxT("aliasstart")) && (nValue >= 0))
aliasStart = nValue;
else if (!wxStricmp(attr, wxT("aliaslen")) && (nValue >= 0))
aliasLen = nValue;
else if (!wxStricmp(attr, wxT("aliaschannel")) && XMLValueChecker::IsValidChannel(aliasChannel))
aliasChannel = nValue;
else if (!wxStricmp(attr, wxT("summarylen")) && (nValue > 0))
summaryLen = nValue;
else if (!wxStricmp(attr, wxT("norms")))
noRMS = (nValue != 0);
}
}
return new LegacyAliasBlockFile(summaryFileName, aliasFileName,
aliasStart, aliasLen, aliasChannel,
summaryLen, noRMS);
}
bool CFilterConditionsDialog::ValidateFilter(wxString& error, bool allow_empty /*=false*/)
{
const unsigned int size = m_currentFilter.filters.size();
if (!size)
{
if (allow_empty)
return true;
error = _("Each filter needs at least one condition.");
return false;
}
wxASSERT(m_filterControls.size() == m_currentFilter.filters.size());
for (unsigned int i = 0; i < size; i++)
{
const CFilterControls& controls = m_filterControls[i];
enum t_filterType type = GetTypeFromTypeSelection(controls.pType->GetSelection());
if ((type == filter_name || type == filter_path) && controls.pValue->GetValue() == _T(""))
{
if (allow_empty)
continue;
m_pListCtrl->SelectLine(i);
controls.pValue->SetFocus();
error = _("At least one filter condition is incomplete");
SetFilterCtrlState(false);
return false;
}
else if (type == filter_size)
{
const wxString v = controls.pValue->GetValue();
if (v == _T("") && allow_empty)
continue;
long number;
if (!v.ToLong(&number) || number < 0)
{
m_pListCtrl->SelectLine(i);
controls.pValue->SetFocus();
error = _("Invalid size in condition");
SetFilterCtrlState(false);
return false;
}
}
}
return true;
}
virtual void UpdateUI(const wxString& key, const wxString& value)
{
size_t i = 0;
for(; i < NumPoliticsCards; ++i)
{
if(sPoliticsCards[i].type == key)
{
value.ToLong(&sPoliticsCards[i].value);
break;
}
}
wxASSERT(i != NumPoliticsCards);
}
// Used for sorting disk usage values
static int CompareDiskUsage(const wxString& strFirst, const wxString& strSecond) {
long lFirstValue;
long lSecondValue;
// Is first measured in GB and second measured in MB?
if ((strFirst.Find(wxT("GB")) != -1) && (strSecond.Find(wxT("MB")) != -1)) return 1;
// Is first measured in MB and second measured in GB?
if ((strFirst.Find(wxT("MB")) != -1) && (strSecond.Find(wxT("GB")) != -1)) return -1;
// Convert to numbers
strFirst.ToLong(&lFirstValue);
strSecond.ToLong(&lSecondValue);
// Is lFirstValue larger than lSecondValue?
if (lFirstValue > lSecondValue) return 1;
// Is lFirstValue less than lSecondValue?
if (lFirstValue < lSecondValue) return -1;
// they must be equal
return 0;
}
