18#include "../../SpectrumAnalyst.h"
19#include "../../LabelTrack.h"
24#include "../../ProjectSettings.h"
25#include "../../ProjectWindow.h"
26#include "../../RefreshCode.h"
27#include "../../SelectUtilities.h"
30#include "../../TrackArtist.h"
31#include "../../TrackPanelAx.h"
32#include "../../TrackPanel.h"
33#include "../../TrackPanelDrawingContext.h"
34#include "../../TrackPanelMouseEvent.h"
38#include "../../prefs/SpectrogramSettings.h"
39#include "../../../images/Cursors.h"
71 float minFreq, maxFreq;
75 return trackTopEdge + wxInt64((1.0 - p) * trackHeight);
82 wxInt64 mouseYCoordinate,
86 const double rate = wt->
GetRate();
97 float minFreq, maxFreq;
101 const double p = double(mouseYCoordinate - trackTopEdge) / trackHeight;
119 pChannelView->
FindTrack()->TypeSwitch<
bool>(
122 return settings.SpectralSelectionEnabled();
129#ifdef EXPERIMENTAL_SPECTRAL_EDITING
130 SBBottom, SBTop, SBCenter, SBWidth,
136 const double t0,
const double t1,
138 double selend,
bool onlyWithinSnapDistance,
139 wxInt64 *pPixelDist,
double *pPinValue)
143 wxInt64 pixelDist = std::abs(posS - pos0);
144 bool chooseLeft =
true;
149 chooseLeft = (selend < t0);
152 const wxInt64 rightDist = std::abs(posS - pos1);
153 if (rightDist < pixelDist)
154 chooseLeft =
false, pixelDist = rightDist;
159 if (onlyWithinSnapDistance &&
164 else if (chooseLeft) {
176 wxCoord xx, wxCoord yy,
const ChannelView *pChannelView,
178 bool mayDragWidth,
bool onlyWithinSnapDistance,
179 double *pPinValue = NULL)
187 wxInt64 pixelDist = 0;
193 &pixelDist, pPinValue);
195#ifdef EXPERIMENTAL_SPECTRAL_EDITING
203 bool chooseTime =
true;
204 bool chooseBottom =
true;
205 bool chooseCenter =
false;
209 t0 <= selend && selend < t1 &&
214 static_cast<const WaveTrack*
>(pTrack.get());
215 const wxInt64 bottomSel = (f0 >= 0)
217 : rect.y + rect.height;
218 const wxInt64 topSel = (f1 >= 0)
221 wxInt64 signedBottomDist = (int)(yy - bottomSel);
222 wxInt64 verticalDist = std::abs(signedBottomDist);
223 if (bottomSel == topSel)
225 chooseBottom = (signedBottomDist >= 0);
227 const wxInt64 topDist = std::abs((
int)(yy - topSel));
228 if (topDist < verticalDist)
229 chooseBottom =
false, verticalDist = topDist;
232#ifdef SPECTRAL_EDITING_ESC_KEY
236 const wxInt64 centerSel =
238 const wxInt64 centerDist = abs((
int)(yy - centerSel));
239 if (centerDist < verticalDist)
240 chooseCenter =
true, verticalDist = centerDist,
243 if (verticalDist >= 0 &&
244 verticalDist < pixelDist) {
245 pixelDist = verticalDist;
253 if (onlyWithinSnapDistance &&
258 else if (chooseCenter) {
262 else if (mayDragWidth && fc > 0) {
266 else if (chooseBottom) {
284 static auto selectCursor =
286 return &*selectCursor;
292 static auto envelopeCursor =
294 return &*envelopeCursor;
301 static wxCursor adjustLeftSelectionCursor{ wxCURSOR_POINT_LEFT };
302 static wxCursor adjustRightSelectionCursor{ wxCURSOR_POINT_RIGHT };
304 static auto bottomFrequencyCursor =
305 ::MakeCursor(wxCURSOR_ARROW, BottomFrequencyCursorXpm, 16, 16);
306 static auto topFrequencyCursor =
307 ::MakeCursor(wxCURSOR_ARROW, TopFrequencyCursorXpm, 16, 16);
308 static auto bandWidthCursor =
309 ::MakeCursor(wxCURSOR_ARROW, BandWidthCursorXpm, 16, 16);
316 tip =
XO(
"Click and drag to move left selection boundary.");
317 pCursor = &adjustLeftSelectionCursor;
320 tip =
XO(
"Click and drag to move right selection boundary.");
321 pCursor = &adjustRightSelectionCursor;
323#ifdef EXPERIMENTAL_SPECTRAL_EDITING
325 tip =
XO(
"Click and drag to move bottom selection frequency.");
326 pCursor = &*bottomFrequencyCursor;
329 tip =
XO(
"Click and drag to move top selection frequency.");
330 pCursor = &*topFrequencyCursor;
334#ifndef SPECTRAL_EDITING_ESC_KEY
337 XO(
"Click and drag to move center selection frequency to a spectral peak.") :
338 XO(
"Click and drag to move center selection frequency.");
344 XO(
"Click and drag to move center selection frequency.");
352 tip =
XO(
"Click and drag to adjust frequency bandwidth.");
353 pCursor = &*bandWidthCursor;
364(std::weak_ptr<SelectHandle> &holder,
366 const std::shared_ptr<ChannelView> &pChannelView)
370 auto old = holder.lock();
371 bool oldUseSnap =
true;
374 if( old->mTimerHandler ) {
378 old->mTimerHandler.reset();
380 oldUseSnap = old->mUseSnap;
384 auto result = std::make_shared<SelectHandle>(
385 pChannelView, oldUseSnap,
TrackList::Get(*pProject), st, viewInfo);
392 auto pTrack = pChannelView->FindTrack();
393 if (!pTrack->GetSelected() || !viewInfo.bAdjustSelectionEdges)
399 const wxRect &rect = st.
rect;
400 wxInt64 leftSel = viewInfo.TimeToPosition(viewInfo.selectedRegion.t0(), rect.x);
401 wxInt64 rightSel = viewInfo.TimeToPosition(viewInfo.selectedRegion.t1(), rect.x);
403 wxASSERT(!(rightSel < leftSel));
404 static_cast<void>(leftSel);
405 static_cast<void>(rightSel);
416 wxASSERT( useSnap == newState.
mUseSnap );
422 if ( oldSnapState.Snapped() == newSnapState.Snapped() &&
423 (!oldSnapState.Snapped() ||
424 oldSnapState.outCoord == newSnapState.outCoord) )
431 const std::shared_ptr<ChannelView> &pChannelView,
bool useSnap,
434) : mpView{ pChannelView }
438 SnapPoint{ viewInfo.playRegion.GetLastActiveStart() },
439 SnapPoint{ viewInfo.playRegion.GetLastActiveEnd() },
442 const wxMouseState &state = st.
state;
446 auto pTrack = pChannelView->FindTrack();
462 template <
class A,
class B,
class DIST >
bool within(
A a, B b, DIST d)
464 return (a > b - d) && (a < b + d);
469 const double minFrequency = 1.0;
470 const double maxFrequency = (rate / 2.0);
471 const double frequency =
473 std::max(minFrequency, center));
475 std::min(frequency / minFrequency, maxFrequency / frequency);
530 const auto pView =
mpView.lock();
534 wxMouseEvent &
event = evt.
event;
536 const auto sTrack = trackList.Lock(
FindTrack());
537 const auto pTrack = sTrack.get();
538 const auto pLeader = *trackList.Find(pTrack);
545 bool selectChange = (
547 event.ControlDown() &&
551 bool bShift =
event.ShiftDown();
554 *pProject, *pTrack, bShift,
true, !unsafe);
563 if (event.LeftDClick() && !event.ShiftDown()) {
565 selectionState.SelectNone(trackList);
568 selectionState.SelectTrack(*pLeader,
true,
true);
576 pTrack->TypeSwitch( [&] (
WaveTrack &wt ) {
577 auto time = viewInfo.PositionToTime(event.m_x,
mRect.x);
580 viewInfo.selectedRegion.setTimes(
581 selectedClip->GetPlayStartTime(), selectedClip->GetPlayEndTime());
590 else if (!event.LeftDown())
596 std::make_shared<SelectionStateChanger>(selectionState, trackList);
600 bool bShiftDown =
event.ShiftDown();
601 bool bCtrlDown =
event.ControlDown();
607 if (bShiftDown || bCtrlDown) {
609 selectionState.ChangeSelectionOnShiftClick(trackList, *pTrack);
614 bool bIsSelected =
false;
616 if (!bIsSelected || trackPanel.GetSelectedTrackCount() > 1)
618 selectionState.SelectTrack(*pLeader, !bIsSelected,
true);
625 pView.get(),
mRect,
false,
false, &value);
631#ifdef EXPERIMENTAL_SPECTRAL_EDITING
642#ifdef EXPERIMENTAL_SPECTRAL_EDITING
649 (boundary == SBBottom)
661 const auto wt =
static_cast<const WaveTrack*
>(pTrack);
684 bool startNewSelection =
true;
685 if (pTrack && pTrack->GetSelected()) {
688 if (viewInfo.bAdjustSelectionEdges) {
689#ifdef EXPERIMENTAL_SPECTRAL_EDITING
720 pView.get(),
mRect,
true,
true, &value);
728 startNewSelection =
false;
729#ifdef EXPERIMENTAL_SPECTRAL_EDITING
737#ifdef EXPERIMENTAL_SPECTRAL_EDITING
741 startNewSelection =
false;
753 const auto wt =
static_cast<const WaveTrack*
>(pTrack);
755 startNewSelection =
false;
768 if (startNewSelection) {
770 selectionState.SelectNone(trackList);
771#ifdef EXPERIMENTAL_SPECTRAL_EDITING
777 selectionState.SelectTrack(*pLeader,
true,
true);
794 const auto pView =
mpView.lock();
799 const wxMouseEvent &
event = evt.
event;
814 if (event.CmdDown()) {
830 enum { minimumSizedSelection = 5 };
836 if (wxLongLong(SelStart - x).Abs() < minimumSizedSelection)
841 if (
auto clickedTrack =
844 Track *sTrack = pTrack.get();
845 Track *eTrack = clickedTrack.get();
847 if ( sTrack && eTrack && !event.ControlDown() ) {
849 selectionState.SelectRangeOfTracks( trackList, *sTrack, *eTrack );
852 #ifdef EXPERIMENTAL_SPECTRAL_EDITING
853 #ifndef SPECTRAL_EDITING_ESC_KEY
855 !viewInfo.selectedRegion.isPoint())
857 (pProject, viewInfo, y,
mRect.y,
mRect.height, pView.get());
890 const auto pView =
mpView.lock();
911 auto &state = st.
state;
913 auto xx = viewInfo.TimeToPosition(time,
mRect.x);
915 const bool bMultiToolMode =
919 if (bMultiToolMode) {
928 keyStr =
_(
"Edit, Preferences...");
931 tip =
XO(
"Multi-Tool Mode: %s for Mouse and Keyboard Preferences.")
934 if (!pTrack->GetSelected() ||
935 !viewInfo.bAdjustSelectionEdges)
938 const wxRect &rect = st.
rect;
939 const bool bShiftDown = state.ShiftDown();
940 const bool bCtrlDown = state.ControlDown();
941 const bool bModifierDown = bShiftDown || bCtrlDown;
948 pView.get(), rect, !bModifierDown, !bModifierDown);
958#ifdef EXPERIMENTAL_SPECTRAL_EDITING
962 tip =
XO(
"Click and drag to set frequency bandwidth.");
963 pCursor = &*envelopeCursor;
969 if (!pTrack->GetSelected() || !viewInfo.bAdjustSelectionEdges)
972 const wxRect &rect = st.
rect;
973 const bool bShiftDown = state.ShiftDown();
974 const bool bCtrlDown = state.ControlDown();
975 const bool bModifierDown = bShiftDown || bCtrlDown;
977 viewInfo, xx, state.m_y,
978 pView.get(), rect, !bModifierDown, !bModifierDown);
983 tip =
XO(
"Click and drag to select audio");
988 XO(
"(snapping)"),
wxT(
" ")
991 return { tip, pCursor };
1023 const wxRect &rect,
unsigned iPass )
1026 auto &dc = context.
dc;
1038 const wxRect &rect,
const wxRect &panelRect,
unsigned iPass )
1048 auto pView =
mpView.lock();
1052 return pView->FindTrack();
1057 mTimerHandler = std::make_shared<TimerHandler>(
this, pProject );
1105 window.TP_ScrollRight();
1109 window.TP_ScrollLeft();
1117 trackPanel.ClientToScreen(&xx, &yy);
1120 window.TP_ScrollLeft();
1124 ::wxDisplaySize(&width, &height);
1125 if (xx == width - 1) {
1127 window.TP_ScrollRight();
1139 wxMouseEvent evt(wxEVT_MOTION);
1140 const auto size = trackPanel.GetSize();
1170 ViewInfo &viewInfo,
int mouseXCoordinate,
int trackLeftEdge,
1178 std::max(0.0, viewInfo.
PositionToTime(mouseXCoordinate, trackLeftEdge));
1179 double origSelend = selend;
1203 selend = origSelend;
1227 int mouseYCoordinate,
int trackTopEdge,
1241 trackTopEdge, trackHeight);
1248 int mouseYCoordinate,
int trackTopEdge,
1258 const double rate = wt->
GetRate();
1259 const double frequency =
1261 trackTopEdge, trackHeight);
1265 if (frequency == rate || frequency < 1.0)
1275 frequency / ratio, frequency * ratio);
1281 if (frequency == rate || frequency < 1.0)
1293 ratio = 1.0 / ratio;
1302 const bool bottomDefined =
1304 const bool topDefined =
1306 if (!bottomDefined || (topDefined &&
mFreqSelPin < frequency)) {
1308 if (frequency == rate)
1318 if (frequency < 1.0)
1330(
const ViewInfo &viewInfo,
bool shiftDown,
const WaveTrack *pTrack,
double value)
1340#ifndef SPECTRAL_EDITING_ESC_KEY
1356 static const size_t minLength = 8;
1358 const double rate = pTrack->
GetRate();
1361 std::vector<float> frequencySnappingData;
1367 std::min(frequencySnappingData.max_size(),
1370 const auto effectiveLength = std::max(minLength, length);
1371 frequencySnappingData.resize(effectiveLength, 0.0f);
1373 &frequencySnappingData[0],
1382 auto windowSize =
settings.GetFFTLength();
1384 while(windowSize > effectiveLength)
1386 const int windowType =
settings.windowType;
1390 &frequencySnappingData[0], length);
1400 auto pTrack = pChannelView->
FindTrack().get();
1402 pTrack->GetSelected() &&
1413 const double rate = wt->
GetRate();
1414 const double frequency =
1416 trackTopEdge, trackHeight);
1417 const double snappedFrequency =
1419 const double maxRatio =
findMaxRatio(snappedFrequency, rate);
1424 if (f1 >= f0 && f0 >= 0)
1426 ratio =
sqrt(f1 / f0);
1432 snappedFrequency / ratio, snappedFrequency * ratio);
1450 const auto windowSize =
settings.GetFFTLength();
1451 const double rate = pTrack->
GetRate();
1452 const double nyq = rate / 2.0;
1453 const double binFrequency = rate / windowSize;
1457 if (centerFrequency <= 0) {
1458 centerFrequency = up ? binFrequency : nyq;
1459 f1 = centerFrequency *
sqrt(2.0);
1462 double ratio = f1 / centerFrequency;
1463 const int originalBin = floor(0.5 + centerFrequency / binFrequency);
1464 const int limitingBin = up ? floor(0.5 + nyq / binFrequency) : 1;
1470 double snappedFrequency = centerFrequency;
1471 int bin = originalBin;
1473 while (snappedFrequency <= centerFrequency &&
1475 snappedFrequency = analyst.
FindPeak(++bin * binFrequency, NULL);
1478 while (snappedFrequency >= centerFrequency &&
1480 snappedFrequency = analyst.
FindPeak(--bin * binFrequency, NULL);
1484 const double maxRatio =
findMaxRatio(snappedFrequency, rate);
1488 (snappedFrequency / ratio, snappedFrequency * ratio);
1493void SelectHandle::ResetFreqSelectionPin
1494 (
const ViewInfo &viewInfo,
double hintFrequency,
bool logF)
1496 switch (mFreqSelMode) {
1511 if (f0 >= 0 && f1 >= 0)
1531 const double logf1 = log(std::max(1.0, f1));
1532 const double logf0 = log(std::max(1.0, f0));
1533 const double logHint = log(std::max(1.0, hintFrequency));
1534 if (std::abs(logHint - logf1) < std::abs(logHint - logf0))
1542 std::abs(hintFrequency - f1) < std::abs(hintFrequency - f0))
std::shared_ptr< UIHandle > UIHandlePtr
size_t limitSampleBufferSize(size_t bufferSize, sampleCount limit)
@ SELECTION_RESIZE_REGION
std::vector< SnapPoint > SnapPointArray
static Settings & settings()
std::unique_ptr< wxCursor > MakeCursor(int WXUNUSED(CursorId), const char *const pXpm[36], int HotX, int HotY)
bool within(A a, B b, DIST d)
std::shared_ptr< Subclass > AssignUIHandlePtr(std::weak_ptr< Subclass > &holder, const std::shared_ptr< Subclass > &pNew)
The top-level handle to an Audacity project. It serves as a source of events that other objects can b...
static ChannelView & Get(Channel &channel)
virtual bool IsSpectral() const
static CommandManager & Get(AudacityProject &project)
NormalizedKeyString GetKeyFromName(const CommandID &name) const
std::shared_ptr< Track > FindTrack()
A LabelTrack is a Track that holds labels (LabelStruct).
bool setTimes(double t0, double t1)
bool setF0(double f, bool maySwap=true)
bool setFrequencies(double f0, double f1)
bool setF1(double f, bool maySwap=true)
float PositionToValue(float pp) const
float ValueToPosition(float val) const
Subscription Subscribe(Callback callback)
Connect a callback to the Publisher; later-connected are called earlier.
A move-only handle representing a connection to a Publisher.
bool IsAudioActive() const
static ProjectAudioIO & Get(AudacityProject &project)
void ModifyState(bool bWantsAutoSave)
static ProjectHistory & Get(AudacityProject &project)
static ProjectSettings & Get(AudacityProject &project)
PlaybackScroller & GetPlaybackScroller()
static ProjectWindow & Get(AudacityProject &project)
void OnTimer(Observer::Message)
TimerHandler(SelectHandle *pParent, AudacityProject *pProject)
AudacityProject * mConnectedProject
Observer::Subscription mSubscription
SelectHandle(const SelectHandle &)
Result Cancel(AudacityProject *) override
wxRect DrawingArea(TrackPanelDrawingContext &, const wxRect &rect, const wxRect &panelRect, unsigned iPass) override
void HandleCenterFrequencyClick(const ViewInfo &viewInfo, bool shiftDown, const WaveTrack *pTrack, double value)
std::weak_ptr< Track > FindTrack()
std::weak_ptr< const WaveTrack > mFreqSelTrack
Result Release(const TrackPanelMouseEvent &event, AudacityProject *pProject, wxWindow *pParent) override
void Enter(bool forward, AudacityProject *pProject) override
void SetUseSnap(bool use, AudacityProject *pProject)
void AssignSelection(ViewInfo &viewInfo, double selend, Track *pTrack)
HitTestPreview Preview(const TrackPanelMouseState &state, AudacityProject *pProject) override
static void SnapCenterOnce(SpectrumAnalyst &analyst, ViewInfo &viewInfo, const WaveTrack *pTrack, bool up)
bool HasEscape(AudacityProject *pProject) const override
void StartFreqSelection(ViewInfo &viewInfo, int mouseYCoordinate, int trackTopEdge, int trackHeight, ChannelView *pChannelView)
Result Click(const TrackPanelMouseEvent &event, AudacityProject *pProject) override
std::shared_ptr< TimerHandler > mTimerHandler
std::shared_ptr< SelectionStateChanger > mSelectionStateChanger
Result Drag(const TrackPanelMouseEvent &event, AudacityProject *pProject) override
std::weak_ptr< ChannelView > mpView
static UIHandlePtr HitTest(std::weak_ptr< SelectHandle > &holder, const TrackPanelMouseState &state, const AudacityProject *pProject, const std::shared_ptr< ChannelView > &pChannelView)
std::shared_ptr< SpectrumAnalyst > mFrequencySnapper
static void StartSnappingFreqSelection(SpectrumAnalyst &analyst, const ViewInfo &viewInfo, const WaveTrack *pTrack)
void AdjustSelection(AudacityProject *pProject, ViewInfo &viewInfo, int mouseXCoordinate, int trackLeftEdge, Track *pTrack)
Extend or contract the existing selection.
bool Escape(AudacityProject *pProject) override
std::shared_ptr< SnapManager > mSnapManager
enum SelectHandle::eFreqSelMode FREQ_SEL_INVALID
@ FREQ_SEL_SNAPPING_CENTER
static UIHandle::Result NeedChangeHighlight(const SelectHandle &oldState, const SelectHandle &newState)
void Draw(TrackPanelDrawingContext &context, const wxRect &rect, unsigned iPass) override
void AdjustFreqSelection(const WaveTrack *wt, ViewInfo &viewInfo, int mouseYCoordinate, int trackTopEdge, int trackHeight)
SelectedRegion mInitialSelection
void MoveSnappingFreqSelection(AudacityProject *pProject, ViewInfo &viewInfo, int mouseYCoordinate, int trackTopEdge, int trackHeight, ChannelView *pChannelView)
void Connect(AudacityProject *pProject)
void StartSelection(AudacityProject *pProject)
Reset our selection markers.
static const int UndefinedFrequency
static void SelectTrackLength(ViewInfo &viewInfo, Track &track, bool syncLocked)
static SelectionState & Get(AudacityProject &project)
void GetBounds(const WaveTrack &wt, float &min, float &max) const
static SpectrogramBounds & Get(WaveTrack &track)
Get either the global default settings, or the track's own if previously created.
static SpectrogramSettings & Get(const WaveTrack &track)
Mutative access to attachment even if the track argument is const.
Used for finding the peaks, for snapping to peaks.
float FindPeak(float xPos, float *pY) const
bool Calculate(Algorithm alg, int windowFunc, size_t windowSize, double rate, const float *data, size_t dataLen, float *pYMin=NULL, float *pYMax=NULL, FreqGauge *progress=NULL)
bool IsSyncLocked() const
static SyncLockState & Get(AudacityProject &project)
Abstract base class for an object holding data associated with points on a time axis.
std::shared_ptr< Subclass > SharedPointer()
A flat linked list of tracks supporting Add, Remove, Clear, and Contains, serialization of the list o...
std::shared_ptr< Subclass > Lock(const std::weak_ptr< Subclass > &wTrack)
static TrackList & Get(AudacityProject &project)
static wxRect MaximizeHeight(const wxRect &rect, const wxRect &panelRect)
void Refresh(bool eraseBackground=true, const wxRect *rect=(const wxRect *) NULL) override
static TrackPanel & Get(AudacityProject &project)
Holds a msgid for the translation catalog; may also bind format arguments.
TranslatableString & Join(TranslatableString arg, const wxString &separator={}) &
Append another translatable string.
NotifyingSelectedRegion selectedRegion
static ViewInfo & Get(AudacityProject &project)
This allows multiple clips to be a part of one WaveTrack.
A Track that contains audio waveform data.
const WaveClip * GetClipAtTime(double time) const
double GetRate() const override
bool GetFloats(float *buffer, sampleCount start, size_t len, fillFormat fill=FillFormat::fillZero, bool mayThrow=true, sampleCount *pNumWithinClips=nullptr) const
"narrow" overload fetches first channel only
sampleCount TimeToLongSamples(double t0) const
double PositionToTime(int64 position, int64 origin=0, bool ignoreFisheye=false) const
int64 TimeToPosition(double time, int64 origin=0, bool ignoreFisheye=false) const
STM: Converts a project time to screen x position.
auto end(const Ptr< Type, BaseDeleter > &p)
Enables range-for.
Namespace containing an enum 'what to do on a refresh?'.
void DoListSelection(AudacityProject &project, Track &t, bool shift, bool ctrl, bool modifyState)
wxCursor * EnvelopeCursor()
double findMaxRatio(double center, double rate)
void SetTipAndCursorForBoundary(SelectionBoundary boundary, bool frequencySnapping, TranslatableString &tip, wxCursor *&pCursor)
wxInt64 FrequencyToPosition(const WaveTrack *wt, double frequency, wxInt64 trackTopEdge, int trackHeight)
Converts a frequency to screen y position.
double PositionToFrequency(const WaveTrack *wt, bool maySnap, wxInt64 mouseYCoordinate, wxInt64 trackTopEdge, int trackHeight)
void SetIfNotNull(T *pValue, const T Value)
SelectionBoundary ChooseTimeBoundary(const double t0, const double t1, const ViewInfo &viewInfo, double selend, bool onlyWithinSnapDistance, wxInt64 *pPixelDist, double *pPinValue)
bool isSpectralSelectionView(const ChannelView *pChannelView)
SelectionBoundary ChooseBoundary(const ViewInfo &viewInfo, wxCoord xx, wxCoord yy, const ChannelView *pChannelView, const wxRect &rect, bool mayDragWidth, bool onlyWithinSnapDistance, double *pPinValue=NULL)
wxCursor * SelectCursor()
__finl float_x4 __vecc sqrt(const float_x4 &a)
wxString Display(bool usesSpecialChars=false) const
Default message type for Publisher.
std::shared_ptr< TrackPanelCell > pCell