{

NumericTextCtrlAx(NumericTextCtrl * ctrl);

virtual ~ NumericTextCtrlAx();

// Performs the default action. childId is 0 (the action for this object)

// or > 0 (the action for a child).

// Return wxACC_NOT_SUPPORTED if there is no default action for this

// window (e.g. an edit control).

wxAccStatus DoDefaultAction(int childId) override;

// Retrieves the address of an IDispatch interface for the specified child.

// All objects must support this property.

wxAccStatus GetChild(int childId, wxAccessible **child) override;

// Gets the number of children.

wxAccStatus GetChildCount(int *childCount) override;

// Gets the default action for this object (0) or > 0 (the action for a child).

// Return wxACC_OK even if there is no action. actionName is the action, or the empty

// string if there is no action.

// The retrieved string describes the action that is performed on an object,

// not what the object does as a result. For example, a toolbar button that prints

// a document has a default action of "Press" rather than "Prints the current document."

wxAccStatus GetDefaultAction(int childId, wxString *actionName) override;

// Returns the description for this object or a child.

wxAccStatus GetDescription(int childId, wxString *description) override;

// Gets the window with the keyboard focus.

// If childId is 0 and child is NULL, no object in

// this subhierarchy has the focus.

// If this object has the focus, child should be 'this'.

wxAccStatus GetFocus(int *childId, wxAccessible **child) override;

// Returns help text for this object or a child, similar to tooltip text.

wxAccStatus GetHelpText(int childId, wxString *helpText) override;

// Returns the keyboard shortcut for this object or child.

// Return e.g. ALT+K

wxAccStatus GetKeyboardShortcut(int childId, wxString *shortcut) override;

// Returns the rectangle for this object (id = 0) or a child element (id > 0).

// rect is in screen coordinates.

wxAccStatus GetLocation(wxRect & rect, int elementId) override;

// Gets the name of the specified object.

wxAccStatus GetName(int childId, wxString *name) override;

// Returns a role constant.

wxAccStatus GetRole(int childId, wxAccRole *role) override;

// Gets a variant representing the selected children

// of this object.

// Acceptable values:

// - a null variant (IsNull() returns TRUE)

// - a list variant (GetType() == wxT("list"))

// - an integer representing the selected child element,

// or 0 if this object is selected (GetType() == wxT("long"))

// - a "void*" pointer to a wxAccessible child object

wxAccStatus GetSelections(wxVariant *selections) override;

// Returns a state constant.

wxAccStatus GetState(int childId, long *state) override;

// Returns a localized string representing the value for the object

// or child.

wxAccStatus GetValue(int childId, wxString *strValue) override;

NumericTextCtrl *mCtrl;

int mLastField;

int mLastDigit;

wxString mCachedName;

wxString mLastCtrlString;

{

NumericFormatSymbol name;

NumericConverter::FormatStrings formatStrings;

friend inline bool operator ==

(const BuiltinFormatString &a, const BuiltinFormatString &b)

{ return a.name == b.name; }

{

NumericField(bool _frac, int _base, int _range, bool _zeropad)

{

frac = _frac;

base = _base;

range = _range;

zeropad = _zeropad;

digits = 0;

}

NumericField( const NumericField & ) = default;

NumericField &operator = ( const NumericField & ) = default;

//NumericField( NumericField && ) = default;

//NumericField &operator = ( NumericField && ) = default;

void CreateDigitFormatStr()

{

if (range > 1)

digits = (int)ceil(log10(range-1.0));

else

digits = 5; // hack: default

if (zeropad && range>1)

formatStr.Printf(wxT("%%0%dd"), digits); // ex. "%03d" if digits is 3

else {

formatStr.Printf(wxT("%%0%dd"), digits);

}

}

bool frac; // is it a fractional field

int base; // divide by this (multiply, after decimal point)

int range; // then take modulo this

int digits;

int pos; // Index of this field in the ValueString

int fieldX; // x-position of the field on-screen

int fieldW; // width of the field on-screen

int labelX; // x-position of the label on-screen

bool zeropad;

wxString label;

wxString formatStr;

wxString str;

{

DigitInfo(int _field, int _index, int _pos, wxRect _box)

{

field = _field;

index = _index;

pos = _pos;

digitBox = _box;

}

int field; // Which field

int index; // Index of this digit within the field

int pos; // Position in the ValueString

wxRect digitBox;

(NumericConverter::Type type)

{

switch (type) {

default:

case NumericConverter::TIME:

return WXSIZEOF(TimeConverterFormats_);

case NumericConverter::FREQUENCY:

return WXSIZEOF(FrequencyConverterFormats_);

case NumericConverter::BANDWIDTH:

return WXSIZEOF(BandwidthConverterFormats_);

}

{

if (id.empty()) {

if (type == TIME)

return DefaultSelectionFormat();

else

return ChooseBuiltinFormatStrings(type)[0].name;

}

else {

auto begin = ChooseBuiltinFormatStrings(type);

auto end = begin + ChooseNBuiltinFormatStrings(type);

auto iter = std::find( begin, end, BuiltinFormatString{ id, {} } );

if (iter == end)

iter = begin;

return iter->name;

}

const NumericFormatSymbol & formatName,

double value,

double sampleRate)

: mBuiltinFormatStrings( ChooseBuiltinFormatStrings( type ) )

, mNBuiltins( ChooseNBuiltinFormatStrings( type ) )

{

ResetMinValue();

ResetMaxValue();

mInvalidValue = -1.0;

mDefaultNdx = 0;

mType = type;

if (type == NumericConverter::TIME )

mDefaultNdx = 4; // Default to "hh:mm:ss + milliseconds".

mScalingFactor = 1.0f;

mSampleRate = 1.0f;

mNtscDrop = false;

mFocusedDigit = 0;

mValue = value; // used in SetSampleRate, reassigned later

SetSampleRate(sampleRate);

SetFormatName(formatName);

SetValue(value); // mValue got overridden to -1 in ControlsToValue(), reassign

const TranslatableString & untranslatedFormat)

{

auto format = untranslatedFormat.Translation();

mPrefix = wxT("");

mFields.clear();

mDigits.clear();

mScalingFactor = 1.0;

// We will change inFrac to true when we hit our first decimal point.

bool inFrac = false;

int fracMult = 1;

int numWholeFields = 0;

int numFracFields = 0;

wxString numStr;

wxString delimStr;

unsigned int i;

mNtscDrop = false;

for(i=0; i<format.length(); i++) {

bool handleDelim = false;

bool handleNum = false;

if (format[i] == '|') {

wxString remainder = format.Right(format.length() - i - 1);

// For languages which use , as a separator.

remainder.Replace(wxT(","), wxT("."));

if (remainder == wxT("#"))

mScalingFactor = mSampleRate;

else if (remainder == wxT("N")) {

mNtscDrop = true;

}

else

// Use the C locale here for string to number.

// Translations are often incomplete.

// We can't rely on the correct ',' or '.' in the

// translation, so we work based on '.' for decimal point.

remainder.ToCDouble(&mScalingFactor);

i = format.length()-1; // force break out of loop

if (!delimStr.empty())

handleDelim = true;

if (!numStr.empty())

handleNum = true;

}

else if ((format[i] >= '0' && format[i] <='9') ||

format[i] == wxT('*') || format[i] == wxT('#')) {

numStr += format[i];

if (!delimStr.empty())

handleDelim = true;

}

else {

delimStr += format[i];

if (!numStr.empty())

handleNum = true;

}

if (i == format.length() - 1) {

if (!numStr.empty())

handleNum = true;

if (!delimStr.empty())

handleDelim = true;

}

if (handleNum) {

bool zeropad = false;

long range = 0;

if (numStr.Right(1) == wxT("#"))

range = (long int)mSampleRate;

else if (numStr.Right(1) != wxT("*")) {

numStr.ToLong(&range);

}

if (numStr.GetChar(0)=='0' && numStr.length()>1)

zeropad = true;

// Hack: always zeropad

zeropad = true;

if (inFrac) {

int base = fracMult * range;

mFields.push_back(NumericField(inFrac, base, range, zeropad));

fracMult *= range;

numFracFields++;

}

else {

unsigned int j;

for(j=0; j<mFields.size(); j++)

mFields[j].base *= range;

mFields.push_back(NumericField(inFrac, 1, range, zeropad));

numWholeFields++;

}

numStr = wxT("");

}

if (handleDelim) {

bool goToFrac = false;

if (!inFrac) {

wxChar delim = delimStr[delimStr.length()-1];

if (delim=='<' || delim=='>') {

goToFrac = true;

if (delimStr.length() > 1)

delimStr = delimStr.BeforeLast(delim);

}

}

if (inFrac) {

if (numFracFields == 0) {

// Should never happen

return;

}

if (handleNum && numFracFields > 1)

mFields[mFields.size()-2].label = delimStr;

else

mFields[mFields.size()-1].label = delimStr;

}

else {

if (numWholeFields == 0)

mPrefix = delimStr;

else {

delimStr.Replace(wxT("<"), wxT(","));

delimStr.Replace(wxT(">"), wxT("."));

mFields[numWholeFields-1].label = delimStr;

}

}

if (goToFrac)

inFrac = true;

delimStr = wxT("");

}

}

for(i = 0; i < mFields.size(); i++) {

mFields[i].CreateDigitFormatStr();

}

int pos = 0;

int j;

mValueMask = wxT("");

mValueTemplate = wxT("");

mValueTemplate += mPrefix;

for(j=0; j<(int)mPrefix.length(); j++)

mValueMask += wxT(".");

pos += mPrefix.length();

for(i = 0; i < mFields.size(); i++) {

mFields[i].pos = pos;

for(j=0; j<mFields[i].digits; j++) {

mDigits.push_back(DigitInfo(i, j, pos, wxRect()));

mValueTemplate += wxT("0");

mValueMask += wxT("0");

pos++;

}

pos += mFields[i].label.length();

mValueTemplate += mFields[i].label;

for(j=0; j<(int)mFields[i].label.length(); j++)

mValueMask += wxT(".");

}

{

unsigned int i;

wxPrintf("%s", (const char *)mPrefix.mb_str());

for(i = 0; i < mFields.size(); i++) {

if (mFields[i].frac) {

wxPrintf("(t * %d) %% %d '%s' ",

mFields[i].base,

mFields[i].range,

(const char *)mFields[i].label.mb_str());

}

else {

wxPrintf("(t / %d) %% %d '%s' ",

mFields[i].base,

mFields[i].range,

(const char *)mFields[i].label.mb_str());

}

}

wxPrintf("\n");

{

//rawValue = 4.9995f; Only for testing!

if (mType == TIME)

rawValue =

floor(rawValue * mSampleRate + (nearest ? 0.5f : 0.0f))

/ mSampleRate; // put on a sample

double theValue =

rawValue * mScalingFactor

// PRL: what WAS this .000001 for? Nobody could explain.

// + .000001

;

sampleCount t_int;

bool round = true;

// We round on the last field. If we have a fractional field we round using it.

// Otherwise we round to nearest integer.

for(unsigned int i = 0; i < mFields.size(); i++) {

if (mFields[i].frac)

round = false;

}

if (theValue < 0)

t_int = -1;

else if(round)

t_int = sampleCount(theValue + (nearest ? 0.5f : 0.0f));

else

{

wxASSERT( mFields.back().frac );

theValue += (nearest ? 0.5f : 0.0f) / mFields.back().base;

t_int = sampleCount(theValue);

}

double t_frac;

if (theValue < 0)

t_frac = -1;

else

t_frac = (theValue - t_int.as_double() );

unsigned int i;

int tenMins;

int mins;

int addMins;

int secs;

int frames;

mValueString = mPrefix;

if(mNtscDrop && theValue >= 0) {

frames = (int)(theValue*30./1.001 + (nearest ? 0.5f : 0.0f));

tenMins = frames/17982;

frames -= tenMins*17982;

mins = tenMins * 10;

if(frames >= 1800) {

frames -= 1800;