{

ASliderAx(wxWindow * window);

virtual ~ ASliderAx();

// 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;

{

public:

TipWindow(wxWindow *parent, const TranslatableStrings & labels);

virtual ~TipWindow() {}

wxSize GetSize() const;

void SetPos(const wxPoint & pos);

void SetLabel(const TranslatableString & label);

void OnPaint(wxPaintEvent & event);

TranslatableString mLabel;

int mWidth;

int mHeight;

wxFont mFont;

DECLARE_EVENT_TABLE()

};

BEGIN_EVENT_TABLE(TipWindow, wxFrame)

EVT_PAINT(TipWindow::OnPaint)

END_EVENT_TABLE()

TipWindow::TipWindow(wxWindow *parent, const TranslatableStrings & labels)

: wxFrame(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize,

wxFRAME_SHAPED | wxNO_BORDER | wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT )

{

SetBackgroundStyle(wxBG_STYLE_PAINT);

SetBackgroundColour(wxTransparentColour);

mFont.SetPointSize(sliderFontSize);

mFont.SetFamily(wxFONTFAMILY_SWISS);

mFont.SetStyle(wxFONTSTYLE_NORMAL);

mFont.SetWeight(wxFONTWEIGHT_NORMAL);

mWidth = mHeight = 0;

for ( const auto &label : labels ) {

int width, height;

GetTextExtent(label.Translation(), &width, &height, NULL, NULL, &mFont);

mWidth = std::max( mWidth, width );

mHeight = std::max( mHeight, height );

}

// Pad to allow for curved corners

mWidth += 8;

mHeight += 8;

#if defined(__WXMAC__)

// Use a bitmap region to set the shape since just adding an unfilled path

// will make the window transparent

wxBitmap shape(mWidth, mHeight);

wxMemoryDC dc(shape);

dc.SetPen(*wxBLACK_PEN);

dc.SetBrush(*wxBLACK_BRUSH);

dc.DrawRoundedRectangle(0, 0, mWidth, mHeight, 5);

dc.SelectObject(wxNullBitmap);

SetShape(wxRegion(shape, *wxWHITE));

#else

wxGraphicsPath path = wxGraphicsRenderer::GetDefaultRenderer()->CreatePath();

path.AddRoundedRectangle(0, 0, mWidth, mHeight, 5);

SetShape(path);

#endif

}

wxSize TipWindow::GetSize() const

{

return wxSize(mWidth, mHeight);

}

void TipWindow::SetPos(const wxPoint & pos)

{

SetSize(pos.x, pos.y, mWidth, mHeight);

}

void TipWindow::SetLabel(const TranslatableString & label)

{

mLabel = label;

}

void TipWindow::OnPaint(wxPaintEvent & WXUNUSED(event))

{

wxAutoBufferedPaintDC dc(this);

dc.SetPen(*wxBLACK_PEN);

dc.SetBrush(AColor::tooltipBrush);

dc.DrawRoundedRectangle(0, 0, mWidth, mHeight, 5);

dc.SetFont(mFont);

dc.SetTextForeground(AColor::tooltipPen.GetColour());

int textWidth, textHeight;

const auto visibleLabel = mLabel.Translation();

dc.GetTextExtent(visibleLabel, &textWidth, &textHeight);

dc.DrawText(visibleLabel, (mWidth - textWidth) / 2, (mHeight - textHeight) / 2);

}

BEGIN_EVENT_TABLE(SliderDialog, wxDialogWrapper)

EVT_TEXT( wxID_ANY, SliderDialog::OnTextChange )

EVT_SLIDER(wxID_ANY,SliderDialog::OnSlider)

END_EVENT_TABLE();

SliderDialog::SliderDialog(wxWindow * parent, wxWindowID id,

const TranslatableString & title,

wxPoint position,

wxSize size,

int style,

float value,

float line,

float page,

LWSlider * pSource):

wxDialogWrapper(parent,id,title,position),

mStyle(style)

{

SetName();

mpOrigin = pSource;

mValue = mpOrigin->Get(false);

auto prec = 2;

auto trailing = NumValidatorStyle::TWO_TRAILING_ZEROES;

if (style == DB_SLIDER)

{

prec = 1;

trailing = NumValidatorStyle::ONE_TRAILING_ZERO;

}

ShuttleGui S(this, eIsCreating);

S.StartVerticalLay();

{

if (style == PAN_SLIDER)

{

mTextCtrl = S

.Validator<IntegerValidator<float>>(

&mValue, NumValidatorStyle::DEFAULT, -100.0, 100.0)

.AddTextBox({}, wxEmptyString, 15);

}

else if (style == VEL_SLIDER)

{

mTextCtrl = S

.Validator<IntegerValidator<float>>(

&mValue, NumValidatorStyle::DEFAULT, -50.0, 50.0)

.AddTextBox({}, wxEmptyString, 15);

}

else

{

mTextCtrl = S

.Validator<FloatingPointValidator<float>>(

prec, &mValue, trailing, mpOrigin->GetMinValue(), mpOrigin->GetMaxValue())

.AddTextBox({}, wxEmptyString, 15);

}

mSlider = safenew ASlider(S.GetParent(),

wxID_ANY,

title,

wxDefaultPosition,

size,

ASlider::Options{}

.Style( style ).Line( line ).Page( page ).Popup( false) );

S.Position(wxEXPAND)

.AddWindow(mSlider);

}

S.EndVerticalLay();

S.AddStandardButtons(eOkButton | eCancelButton);

Fit();

mSlider->Set(value);

}

SliderDialog::~SliderDialog()

{

}

bool SliderDialog::TransferDataToWindow()

{

float value = mSlider->Get(false);

mValue = mStyle == PAN_SLIDER

? value * 100.0

: value;

mTextCtrl->GetValidator()->TransferToWindow();

mTextCtrl->SetSelection(-1, -1);

if (mpOrigin) {

mpOrigin->Set(value);

mpOrigin->SendUpdate(value);

}

return true;

}

bool SliderDialog::TransferDataFromWindow()

{

if (mTextCtrl->GetValidator()->TransferFromWindow())

{

float value = mValue;

if (mStyle == DB_SLIDER)

value = DB_TO_LINEAR(value);

else if (mStyle == PAN_SLIDER)

value /= 100.0;

mSlider->Set(value);

if (mpOrigin) {

mpOrigin->Set(value);

mpOrigin->SendUpdate(value);

}

}

return true;

}

void SliderDialog::OnSlider(wxCommandEvent & event)

{

TransferDataToWindow();

event.Skip(false);

}

void SliderDialog::OnTextChange(wxCommandEvent & event)

{

if (mTextCtrl->GetValidator()->TransferFromWindow())

{

TransferDataFromWindow();

}

event.Skip(false);

}

float SliderDialog::Get()

{

return mSlider->Get(false);

}

static const wxPoint2DDouble outer[] =

{

wxPoint2DDouble( 2, 0 ),

wxPoint2DDouble( 8, 0 ),

wxPoint2DDouble( 10, 2 ),

wxPoint2DDouble( 10, 8 ),

wxPoint2DDouble( 5, 13 ),

wxPoint2DDouble( 0, 8 ),

wxPoint2DDouble( 0, 2 ),

wxPoint2DDouble( 2, 0 )

};

static const wxPoint2DDouble enabledLeftBegin[] =

{

wxPoint2DDouble( 2, 1 ),

wxPoint2DDouble( 1, 2 ),

wxPoint2DDouble( 1, 8 ),

wxPoint2DDouble( 4, 4 ),

wxPoint2DDouble( 4, 7 )

};

static const wxPoint2DDouble enabledLeftEnd[] =

{

wxPoint2DDouble( 8, 1 ),

wxPoint2DDouble( 1, 8 ),

wxPoint2DDouble( 5, 12 ),

wxPoint2DDouble( 6, 4 ),

wxPoint2DDouble( 6, 7 )

};

static const wxPoint2DDouble enabledRightBegin[] =

{

wxPoint2DDouble( 9, 2 ),

wxPoint2DDouble( 9, 8 ),

wxPoint2DDouble( 4, 5 ),

wxPoint2DDouble( 4, 8 ),

};

static const wxPoint2DDouble enabledRightEnd[] =

{

wxPoint2DDouble( 9, 8 ),

wxPoint2DDouble( 6, 11 ),

wxPoint2DDouble( 6, 5 ),

wxPoint2DDouble( 6, 8 )

};

static const wxPoint2DDouble disabledStripesBegin[] =

{

wxPoint2DDouble( 3, 2 ),

wxPoint2DDouble( 5, 2 ),

wxPoint2DDouble( 7, 2 ),

wxPoint2DDouble( 2, 3 ),

wxPoint2DDouble( 2, 5 ),

wxPoint2DDouble( 2, 7 ),

};

static const wxPoint2DDouble disabledStripesEnd[] =

{

wxPoint2DDouble( 8, 7 ),

wxPoint2DDouble( 8, 5 ),

wxPoint2DDouble( 8, 3 ),

wxPoint2DDouble( 7, 8 ),

wxPoint2DDouble( 6, 9 ),

wxPoint2DDouble( 5, 10 ),

};

static const wxPoint2DDouble disabledRightBegin[] =

{

wxPoint2DDouble( 9, 2 ),

wxPoint2DDouble( 9, 8 ),

};

static const wxPoint2DDouble disabledRightEnd[] =

{

wxPoint2DDouble( 9, 8 ),

wxPoint2DDouble( 6, 11 ),

};

LWSlider::LWSlider(wxWindow * parent,

const TranslatableString &name,

const wxPoint &pos,

const wxSize &size,

float minValue,

float maxValue,

float stepValue,

bool canUseShift,

int style,

bool heavyweight /* = false */,

bool popup /* = true */,

int orientation /* = wxHORIZONTAL */) // wxHORIZONTAL or wxVERTICAL. wxVERTICAL is currently only for DB_SLIDER.

{

Init(parent, name, pos, size, minValue, maxValue,

stepValue, canUseShift, style, heavyweight, popup, 1.0, orientation);

}

LWSlider::LWSlider(wxWindow *parent,

const TranslatableString &name,

const wxPoint &pos,

const wxSize &size,

int style,

bool heavyweight /* = false */,

bool popup /* = true */,

int orientation /* = wxHORIZONTAL */) // wxHORIZONTAL or wxVERTICAL. wxVERTICAL is currently only for DB_SLIDER.

{

wxString leftLabel, rightLabel;

float minValue, maxValue, stepValue;

float speed = 1.0;

switch(style)

{

case PAN_SLIDER:

minValue = -1.0f;

maxValue = +1.0f;

stepValue = 0.1f;

orientation = wxHORIZONTAL; //v Vertical PAN_SLIDER currently not handled, forced to horizontal.

break;

case DB_SLIDER:

minValue = -36.0f;

//if (orientation == wxHORIZONTAL)

maxValue = 36.0f;

//else

//maxValue = 36.0f; // for MixerBoard //v Previously was 6dB for MixerBoard, but identical for now.

stepValue = 1.0f;

speed = 0.5;

break;

case FRAC_SLIDER:

minValue = 0.0f;

maxValue = 1.0f;

stepValue = STEP_CONTINUOUS;

break;

case SPEED_SLIDER:

minValue = 0.01f;

maxValue = 3.0f;

stepValue = STEP_CONTINUOUS;

break;

#ifdef EXPERIMENTAL_MIDI_OUT

case VEL_SLIDER:

minValue = VEL_MIN;

maxValue = VEL_MAX;

stepValue = 1.0f;

speed = 0.5;

break;

#endif

default:

minValue = 0.0f;

maxValue = 1.0f;

stepValue = 0.0f;

wxASSERT(false); // undefined style

}

Init(parent, name, pos, size, minValue, maxValue, stepValue,

true, style, heavyweight, popup, speed, orientation);

}

void LWSlider::Init(wxWindow * parent,

const TranslatableString &name,

const wxPoint &pos,

const wxSize &size,

float minValue,

float maxValue,

float stepValue,

bool canUseShift,

int style,

bool heavyweight,

bool popup,

float speed,

int orientation /* = wxHORIZONTAL */) // wxHORIZONTAL or wxVERTICAL. wxVERTICAL is currently only for DB_SLIDER.

{

mEnabled = true;

mName = name;

mStyle = style;

mOrientation = orientation;

mIsDragging = false;

mParent = parent;

mHW = heavyweight;

mPopup = popup;

mSpeed = speed;

mID = wxID_ANY;

mMinValue = minValue;

mMaxValue = maxValue;

mStepValue = stepValue;

mCanUseShift = canUseShift;

mCurrentValue = 0.0f;

mDefaultValue = 0.0f;

mDefaultShortcut = false;

mBitmap = nullptr;

mThumbBitmap = nullptr;

mThumbBitmapHilited = nullptr;

mScrollLine = 1.0f;

mScrollPage = 5.0f;

mTipPanel = NULL;

AdjustSize(size);

Move(pos);

{

SetDefaultShortcut(true);

mDefaultValue = value;

{

line = mScrollLine;

page = mScrollPage;

{

mScrollLine = line;

mScrollPage = page;

{

mLeft = newpos.x;

mTop = newpos.y;

{

mWidth = sz.GetWidth();

mHeight = sz.GetHeight();

if( mBitmap ){

mBitmap.reset();

}

mThumbWidth = 11;

mThumbHeight = 20;

if (mOrientation == wxHORIZONTAL)

{

mCenterY = mHeight - 9;

}

else

{

mCenterX = mWidth - 9;

}

if (mOrientation == wxHORIZONTAL)

{

mLeftX = mThumbWidth/2;

mRightX = mWidth - mThumbWidth/2 - 1;

mWidthX = mRightX - mLeftX;

}

else

{

mTopY = mThumbWidth/2;

mBottomY = mHeight - mThumbWidth/2 - 1;

mHeightY = mBottomY - mTopY;

}

Refresh();

{

// The dc will be a paint DC

if (!mBitmap || !mThumbBitmap || !mThumbBitmapHilited)

{

DrawToBitmap(dc);

}

//thumbPos should be in pixels

int thumbPos = ValueToPosition(mCurrentValue);

int thumbOrtho; // position in axis orthogonal to mOrientation

if (mOrientation == wxHORIZONTAL){

thumbOrtho = mCenterY - (mThumbHeight/2);

thumbPos += 1-mThumbWidth/2;

}

else{

thumbOrtho = mCenterX - (mThumbWidth/2);

thumbPos += 8-mThumbHeight/2;

}

// Draw the background.

// If we are lightweight, this has already been done for us.

if( mHW ){

dc.SetBackground( *wxTRANSPARENT_BRUSH );

dc.Clear();

}

dc.DrawBitmap(*mBitmap, mLeft, mTop, true);

const auto &thumbBitmap =

highlight ? *mThumbBitmapHilited : *mThumbBitmap;

if (mOrientation == wxHORIZONTAL)

{

dc.DrawBitmap(thumbBitmap, mLeft+thumbPos, mTop+thumbOrtho, true);

}

else

{

// TODO: Don't use pixel-count hack in positioning.

dc.DrawBitmap(thumbBitmap, mLeft+thumbOrtho-5, mTop+thumbPos, true);

}

if (mTipPanel)

{

mTipPanel->Update();

}

{

AdjustSize(event.GetSize());

Refresh();

{

// Get correctly oriented thumb.

if (mOrientation == wxVERTICAL){

mThumbBitmap = std::make_unique<wxBitmap>(wxBitmap( theTheme.Bitmap( bmpSliderThumbRotated )));

mThumbBitmapHilited = std::make_unique<wxBitmap>(wxBitmap( theTheme.Bitmap( bmpSliderThumbRotatedHilited )));

}

else {

mThumbBitmap = std::make_unique<wxBitmap>(wxBitmap( theTheme.Bitmap( bmpSliderThumb )));

mThumbBitmapHilited = std::make_unique<wxBitmap>(wxBitmap( theTheme.Bitmap( bmpSliderThumbHilited )));

}

// Now the background bitmap

mBitmap = std::make_unique<wxBitmap>();

mBitmap->Create(mWidth, mHeight, paintDC);

#if defined(__WXMAC__)

mBitmap->UseAlpha();

#endif

// Set up the memory DC

// We draw to it, not the paintDC.

wxMemoryDC dc;

dc.SelectObject(*mBitmap);

dc.SetBackground(wxBrush(mParent->GetBackgroundColour()));

dc.Clear();

// Draw the line along which the thumb moves.

AColor::UseThemeColour(&dc, clrSliderMain );

if (mOrientation == wxHORIZONTAL)

{

AColor::Line(dc, mLeftX, mCenterY, mRightX+2, mCenterY);

AColor::Line(dc, mLeftX, mCenterY+1, mRightX+2, mCenterY+1);

}

else

{

AColor::Line(dc, mCenterX, mTopY, mCenterX, mBottomY+2);

AColor::Line(dc, mCenterX+1, mTopY, mCenterX+1, mBottomY+2);

}

// Draw +/- or L/R first. We need to draw these before the tick marks.

if (mStyle == PAN_SLIDER)

{

//VJ Vertical PAN_SLIDER currently not handled, forced to horizontal.

// sliderFontSize is for the tooltip.

// we need something smaller here...

wxFont labelFont(7, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);

dc.SetFont(labelFont);

// Color

dc.SetTextForeground( theTheme.Colour( clrTrackPanelText ));

/* i18n-hint: One-letter abbreviation for Left, in the Pan slider */

dc.DrawText(_("L"), mLeftX, 0);

/* i18n-hint: One-letter abbreviation for Right, in the Pan slider */

dc.DrawText(_("R"), mRightX - dc.GetTextExtent(_("R")).GetWidth(), 0);

}

else

{

// draw the '-' and the '+'

// These are drawn with lines, rather tha nwith a font.

AColor::UseThemeColour(&dc, clrTrackPanelText );

if (mOrientation == wxHORIZONTAL)

{

AColor::Line(dc, mLeftX, mCenterY-10, mLeftX+4, mCenterY-10);

AColor::Line(dc, mRightX-5, mCenterY-10, mRightX-1, mCenterY-10);

AColor::Line(dc, mRightX-3, mCenterY-12, mRightX-3, mCenterY-8);

}

else

{

// Vertical DB_SLIDER is for gain slider in MixerBoard.

// We use a Ruler instead of marks & ticks.

// Draw '+' and '-' only for other vertical sliders.

if (mStyle != DB_SLIDER)

{

AColor::Line(dc, mCenterX-12, mBottomY-3, mCenterX-8, mBottomY-3);

AColor::Line(dc, mCenterX-12, mTopY+3, mCenterX-8, mTopY+3);

AColor::Line(dc, mCenterX-10, mTopY, mCenterX-10, mTopY+5);

}

}

}

// Use special colour to indicate no ticks.

wxColour TickColour = theTheme.Colour( clrSliderLight );

bool bTicks = TickColour != wxColour(60,60,60);

if( bTicks ) {

// tick marks

int divs = 10;

double upp;

if (mOrientation == wxHORIZONTAL)

{

// Bug #2446 - A bit of a hack, but it should suffice.

divs = (mWidth - 1) / 10;

upp = divs / (double)(mWidthX-1);

}

else

{

if (mStyle == DB_SLIDER)

divs = mMaxValue - mMinValue + 1;

upp = divs / (double)(mHeightY-1);

}

#ifdef OPTIONAL_SLIDER_TICKS

double d = 0.0;

int int_d = -1;

const int kMax = (mOrientation == wxHORIZONTAL) ? mWidthX : mHeightY;

for(int p = 0; p <= kMax; p++)

{

if (((int)d) > int_d)

{

int_d = (int)d;

int tickLength = ((int_d == 0) || (int_d == divs)) ? 5: 3; // longer ticks at extremes

AColor::UseThemeColour(&dc, clrSliderLight );

if (mOrientation == wxHORIZONTAL)

{

AColor::Line(dc, mLeftX+p, mCenterY-tickLength, mLeftX+p, mCenterY-1); // ticks above

}

else

{

AColor::Line(dc, mCenterX-tickLength, mTopY+p, mCenterX-1, mTopY+p); // ticks at left

}

AColor::UseThemeColour(&dc, clrSliderDark );

if (mOrientation == wxHORIZONTAL)

{

AColor::Line(dc, mLeftX+p+1, mCenterY-tickLength+1, mLeftX+p+1, mCenterY-1); // ticks above

}

else

{

AColor::Line(dc, mCenterX-tickLength+1, mTopY+p+1, mCenterX-1, mTopY+p+1); // ticks at left

}

}

d += upp;

}

#endif

}

dc.SelectObject(wxNullBitmap);

// safenew, because SetMask takes ownership

// We always mask. If we are HeavyWeight, the ASlider draws the

// background.

if( !mHW )

{

mBitmap->SetMask(safenew wxMask(*mBitmap, dc.GetBackground().GetColour()));

}

{

if (show)

{

if (mTipPanel)

{

if (mTipPanel->IsShownOnScreen())

{

return;

}

mTipPanel.reset();

}

CreatePopWin();

FormatPopWin();

SetPopWinPosition();

mTipPanel->ShowWithoutActivating();

}

else

{

if (mTipPanel)

{

mTipPanel->Hide();

mTipPanel.reset();

}

}

{

if (mTipPanel)

{

wxSize sz = mTipPanel->GetSize();

wxPoint pt;

if (mOrientation == wxHORIZONTAL)

{

pt.x = mLeft + ((mWidth - sz.x) / 2);

pt.y = mTop + mHeight + 1;

}

else

{

pt.x = mLeft + mWidth + 1;

pt.y = mTop + ((mHeight - sz.y) / 2);

}

mTipPanel->SetPos(mParent->ClientToScreen(pt));

}

{

if (!mTipPanel)

{

return;

}

mTipPanel->SetLabel(GetTip(mCurrentValue));

mTipPanel->Refresh();

{

TranslatableString label;

if (mTipTemplate.empty())

{

TranslatableString val;

switch(mStyle)

{

case FRAC_SLIDER:

val = Verbatim("%.2f").Format( value );

break;

case DB_SLIDER:

/* i18n-hint dB abbreviates decibels */

val = XO("%+.1f dB").Format( value );

break;

case PAN_SLIDER:

if (value == 0.0)

{

val = XO("Center");

}

else

{

const auto v = 100.0f * fabsf(value);

if (value < 0.0)

/* i18n-hint: Stereo pan setting */

val = XO("%.0f%% Left").Format( v );

else

/* i18n-hint: Stereo pan setting */

val = XO("%.0f%% Right").Format( v );

}

break;

case SPEED_SLIDER:

/* i18n-hint: "x" suggests a multiplicative factor */

val = XO("%.2fx").Format( value );

break;

#ifdef EXPERIMENTAL_MIDI_OUT

case VEL_SLIDER:

if (value > 0.0f)

// Signed