// Diffs between r10679 and r10680 // USE_MIDI is DEFINED // Sources are preprocessed and tweaked to eliminate differences due to the // fact that they are in different directories (i.e. the preprocessor sometimes // inserts path names, so I "normalized" them to make them match.) // // Since preprocessor strips out comments, anything like this is a manually // added comment. // // These differences are mostly intentional developments of NoteTrack // display and editing. The point of this file is to look for changes // that do not pertain to NoteTracks or that are specialized to // EXPERIMENTAL_MIDI_OUT or EXPERIMENTAL_SCOREALIGN, which are NOT // defined. // diff -wrcB e79/src/AudacityApp.cpp.E e80/src/AudacityApp.cpp.E *** e79/src/AudacityApp.cpp.E 2010-11-26 08:20:37.000000000 -0500 --- e80/src/AudacityApp.cpp.E 2010-11-26 08:21:11.000000000 -0500 *************** *** 55813,55818 **** --- 55813,55823 ---- typedef class Alg_parameter { public: + + + + + Alg_parameter() { attr = "i"; } ~Alg_parameter(); Alg_attribute attr; union { // this is from allegro.h *************** *** 56115,56121 **** --- 56120,56129 ---- void insert_beat(double time, double beat); bool insert_tempo(double tempo, double beat); + double get_tempo(double beat); + bool set_tempo(double tempo, double start_beat, double end_beat); + bool stretch_region(double b0, double b1, double dur); void cut(double start, double len, bool units_are_seconds); void trim(double start, double end, bool units_are_seconds); void paste(double start, Alg_track *tr); // this is from allegro.h *************** *** 56389,56399 **** void show(); long length() { return len; } int find_beat(double beat); ! void insert(double beat, double num, double den); ! void cut(double start, double end); void trim(double start, double end); void paste(double start, Alg_seq *seq); void insert_beats(double beat, double len); }; --- 56397,56411 ---- void show(); long length() { return len; } int find_beat(double beat); ! ! double get_bar_len(double beat); ! void insert(double beat, double num, double den, bool force = false); ! void cut(double start, double end, double dur); void trim(double start, double end); void paste(double start, Alg_seq *seq); void insert_beats(double beat, double len); + + double nearest_beat(double beat); }; // this is from allegro.h *************** *** 56436,56446 **** --- 56448,56461 ---- typedef struct Alg_pending_event { + void *cookie; Alg_events *events; long index; bool note_on; + double offset; } *Alg_pending_event_ptr; + typedef class Alg_iterator { private: long maxlen; // this is from allegro.h: added time offset field to model NoteTrack offset *************** *** 56452,56459 **** void show(); bool earlier(int i, int j); ! void insert(Alg_events_ptr events, long index, bool note_on); ! bool remove_next(Alg_events_ptr &events, long &index, bool ¬e_on); public: bool note_off_flag; --- 56467,56477 ---- void show(); bool earlier(int i, int j); ! void insert(Alg_events_ptr events, long index, bool note_on, ! void *cookie, double offset); ! ! bool remove_next(Alg_events_ptr &events, long &index, bool ¬e_on, ! void *&cookie, double &offset); public: bool note_off_flag; // this is from allegro.h *************** *** 56464,56480 **** maxlen = len = 0; pending_events = __null; } - ~Alg_iterator(); - void begin(bool note_off_flag = false); ! Alg_event_ptr next(bool *note_on = __null); void end(); } *Alg_iterator_ptr; --- 56482,56500 ---- maxlen = len = 0; pending_events = __null; } + void begin_seq(Alg_seq_ptr s, void *cookie = __null, double offset = 0.0); + ~Alg_iterator(); ! void begin(void *cookie = __null) { begin_seq(seq, cookie); } ! Alg_event_ptr next(bool *note_on = __null, void **cookie_ptr = __null, ! double *offset_ptr = __null, double end_time = 0); void end(); } *Alg_iterator_ptr; // this is from allegro.h *************** *** 56509,56516 **** Alg_seq(Alg_track_ref track) { seq_from_track(track); } Alg_seq(Alg_track_ptr track) { seq_from_track(*track); } void seq_from_track(Alg_track_ref tr); ! Alg_seq(std::istream &file, bool smf); ! Alg_seq(const char *filename, bool smf); virtual ~Alg_seq(); int get_read_error() { return error; } void serialize(void **buffer, long *bytes); --- 56529,56538 ---- Alg_seq(Alg_track_ref track) { seq_from_track(track); } Alg_seq(Alg_track_ptr track) { seq_from_track(*track); } void seq_from_track(Alg_track_ref tr); ! ! Alg_seq(std::istream &file, bool smf, double *offset_ptr = __null); ! ! Alg_seq(const char *filename, bool smf, double *offset_ptr = __null); virtual ~Alg_seq(); int get_read_error() { return error; } void serialize(void **buffer, long *bytes); // this is from allegro.h *************** *** 56523,56531 **** void unserialize_seq(); ! void write(std::ostream &file, bool in_secs); ! bool write(const char *filename); void smf_write(std::ostream &file); bool smf_write(const char *filename); --- 56545,56553 ---- void unserialize_seq(); ! void write(std::ostream &file, bool in_secs, double offset = 0.0); ! bool write(const char *filename, double offset = 0.0); void smf_write(std::ostream &file); bool smf_write(const char *filename); // this is from allegro.h *************** *** 56567,56580 **** --- 56589,56615 ---- long seek_time(double time, int track_num); bool insert_beat(double time, double beat); + + + + + + double nearest_beat_time(double time, double *beat); + bool insert_tempo(double bpm, double beat); + bool stretch_region(double b0, double b1, double dur); + void add_event(Alg_event_ptr event, int track_num); void add(Alg_event_ptr event) { (__builtin_expect(!(false), 0) ? __assert_rtn(__func__, "/Users/rbd/audacity/audacity-rNNN/lib-src/portsmf/allegro.h", NNNN, "false") : (void)0); } + double get_tempo(double beat); bool set_tempo(double bpm, double start_beat, double end_beat); + + + double get_bar_len(double beat); void set_time_sig(double beat, double num, double den); void beat_to_measure(double beat, long *measure, double *m_beat, double *num, double *den); // this is from allegro.h *************** *** 56949,56954 **** --- 56984,56992 ---- static bool IsGoodInt(const wxString strInt); static bool IsValidChannel(const int nValue); + + static bool IsValidVisibleChannels(const int nValue); + static bool IsValidSampleFormat(const int nValue); }; // this is from XMLTagHandler.h -- support for Channel selection button saving *************** *** 56999,57005 **** class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; --- 57037,57043 ---- class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class __attribute__((visibility("default"))) NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; // NOTE: I separated the changes above into lines, and diffed them to determine // that the "true" difference is the following. I don't understand why they // are different, but the change does not seem dangerous. // // < class NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; // --- // > class __attribute__((visibility("default"))) NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; *************** *** 70851,70856 **** --- 70899,70921 ---- bool HitTestEnvelope(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSamples(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSlide(Track *track, wxRect &r, wxMouseEvent & event); + enum StretchEnum { + stretchLeft, + stretchCenter, + stretchRight + }; + StretchEnum mStretchMode; + bool mStretching; + bool mStretched; + double mStretchStart; + + double mStretchSel0; + double mStretchSel1; + double mStretchLeftBeats; + double mStretchRightBeats; + bool HitTestStretch(Track *track, wxRect &r, wxMouseEvent & event); + void Stretch(int mouseXCoordinate, int trackLeftEdge, Track *pTrack); + void HandleSelect(wxMouseEvent & event); // added for the stretch region interaction *************** *** 71080,71085 **** --- 71145,71154 ---- double mHSlideAmount; + + NoteTrack *mCapturedNoteClip; + + bool mDidSlideVertically; bool mRedrawAfterStop; // this was in TrackPanel.h, but it is no longer used anywhere, so I // took it out *************** *** 71143,71148 **** --- 71212,71220 ---- IsOverCutLine, WasOverCutLine, IsPopping, + + IsStretching, + IsZooming }; // added for the stretch region interaction *************** *** 71175,71180 **** --- 71247,71257 ---- wxCursor *mAdjustLeftSelectionCursor; wxCursor *mAdjustRightSelectionCursor; + wxCursor *mStretchCursor; + wxCursor *mStretchLeftCursor; + wxCursor *mStretchRightCursor; + + wxMenu *mWaveTrackMenu; wxMenu *mNoteTrackMenu; wxMenu *mTimeTrackMenu; diff -wrcB e79/src/AudioIO.cpp.E e80/src/AudioIO.cpp.E // added for the stretch region interaction *** e79/src/AudioIO.cpp.E 2010-11-27 06:35:05.000000000 -0500 --- e80/src/AudioIO.cpp.E 2010-11-27 06:35:38.000000000 -0500 *************** *** 51339,51344 **** --- 51339,51349 ---- typedef class Alg_parameter { public: + + + + + Alg_parameter() { attr = "i"; } ~Alg_parameter(); Alg_attribute attr; union { // changes to allegro.h are going to show up again every time it is // included *************** *** 51641,51647 **** --- 51646,51655 ---- void insert_beat(double time, double beat); bool insert_tempo(double tempo, double beat); + double get_tempo(double beat); + bool set_tempo(double tempo, double start_beat, double end_beat); + bool stretch_region(double b0, double b1, double dur); void cut(double start, double len, bool units_are_seconds); void trim(double start, double end, bool units_are_seconds); void paste(double start, Alg_track *tr); *************** *** 51915,51925 **** void show(); long length() { return len; } int find_beat(double beat); ! void insert(double beat, double num, double den); ! void cut(double start, double end); void trim(double start, double end); void paste(double start, Alg_seq *seq); void insert_beats(double beat, double len); }; --- 51923,51937 ---- void show(); long length() { return len; } int find_beat(double beat); ! ! double get_bar_len(double beat); ! void insert(double beat, double num, double den, bool force = false); ! void cut(double start, double end, double dur); void trim(double start, double end); void paste(double start, Alg_seq *seq); void insert_beats(double beat, double len); + + double nearest_beat(double beat); }; *************** *** 51962,51972 **** --- 51974,51987 ---- typedef struct Alg_pending_event { + void *cookie; Alg_events *events; long index; bool note_on; + double offset; } *Alg_pending_event_ptr; + typedef class Alg_iterator { private: long maxlen; *************** *** 51978,51985 **** void show(); bool earlier(int i, int j); ! void insert(Alg_events_ptr events, long index, bool note_on); ! bool remove_next(Alg_events_ptr &events, long &index, bool ¬e_on); public: bool note_off_flag; --- 51993,52003 ---- void show(); bool earlier(int i, int j); ! void insert(Alg_events_ptr events, long index, bool note_on, ! void *cookie, double offset); ! ! bool remove_next(Alg_events_ptr &events, long &index, bool ¬e_on, ! void *&cookie, double &offset); public: bool note_off_flag; *************** *** 51990,52006 **** maxlen = len = 0; pending_events = __null; } - ~Alg_iterator(); - void begin(bool note_off_flag = false); ! Alg_event_ptr next(bool *note_on = __null); void end(); } *Alg_iterator_ptr; --- 52008,52026 ---- maxlen = len = 0; pending_events = __null; } + void begin_seq(Alg_seq_ptr s, void *cookie = __null, double offset = 0.0); + ~Alg_iterator(); ! void begin(void *cookie = __null) { begin_seq(seq, cookie); } ! Alg_event_ptr next(bool *note_on = __null, void **cookie_ptr = __null, ! double *offset_ptr = __null, double end_time = 0); void end(); } *Alg_iterator_ptr; *************** *** 52035,52042 **** Alg_seq(Alg_track_ref track) { seq_from_track(track); } Alg_seq(Alg_track_ptr track) { seq_from_track(*track); } void seq_from_track(Alg_track_ref tr); ! Alg_seq(std::istream &file, bool smf); ! Alg_seq(const char *filename, bool smf); virtual ~Alg_seq(); int get_read_error() { return error; } void serialize(void **buffer, long *bytes); --- 52055,52064 ---- Alg_seq(Alg_track_ref track) { seq_from_track(track); } Alg_seq(Alg_track_ptr track) { seq_from_track(*track); } void seq_from_track(Alg_track_ref tr); ! ! Alg_seq(std::istream &file, bool smf, double *offset_ptr = __null); ! ! Alg_seq(const char *filename, bool smf, double *offset_ptr = __null); virtual ~Alg_seq(); int get_read_error() { return error; } void serialize(void **buffer, long *bytes); *************** *** 52049,52057 **** void unserialize_seq(); ! void write(std::ostream &file, bool in_secs); ! bool write(const char *filename); void smf_write(std::ostream &file); bool smf_write(const char *filename); --- 52071,52079 ---- void unserialize_seq(); ! void write(std::ostream &file, bool in_secs, double offset = 0.0); ! bool write(const char *filename, double offset = 0.0); void smf_write(std::ostream &file); bool smf_write(const char *filename); *************** *** 52093,52106 **** --- 52115,52141 ---- long seek_time(double time, int track_num); bool insert_beat(double time, double beat); + + + + + + double nearest_beat_time(double time, double *beat); + bool insert_tempo(double bpm, double beat); + bool stretch_region(double b0, double b1, double dur); + void add_event(Alg_event_ptr event, int track_num); void add(Alg_event_ptr event) { (__builtin_expect(!(false), 0) ? __assert_rtn(__func__, "/Users/rbd/audacity/audacity-rNNN/lib-src/portsmf/allegro.h", NNNN, "false") : (void)0); } + double get_tempo(double beat); bool set_tempo(double bpm, double start_beat, double end_beat); + + + double get_bar_len(double beat); void set_time_sig(double beat, double num, double den); void beat_to_measure(double beat, long *measure, double *m_beat, double *num, double *den); *************** *** 52382,52387 **** --- 52417,52425 ---- static bool IsGoodInt(const wxString strInt); static bool IsValidChannel(const int nValue); + + static bool IsValidVisibleChannels(const int nValue); + static bool IsValidSampleFormat(const int nValue); }; *************** *** 52432,52438 **** class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; --- 52470,52476 ---- class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class __attribute__((visibility("default"))) NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; *************** *** 57257,57262 **** --- 57305,57327 ---- bool HitTestEnvelope(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSamples(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSlide(Track *track, wxRect &r, wxMouseEvent & event); + enum StretchEnum { + stretchLeft, + stretchCenter, + stretchRight + }; + StretchEnum mStretchMode; + bool mStretching; + bool mStretched; + double mStretchStart; + + double mStretchSel0; + double mStretchSel1; + double mStretchLeftBeats; + double mStretchRightBeats; + bool HitTestStretch(Track *track, wxRect &r, wxMouseEvent & event); + void Stretch(int mouseXCoordinate, int trackLeftEdge, Track *pTrack); + void HandleSelect(wxMouseEvent & event); *************** *** 57486,57491 **** --- 57551,57560 ---- double mHSlideAmount; + + NoteTrack *mCapturedNoteClip; + + bool mDidSlideVertically; bool mRedrawAfterStop; *************** *** 57549,57554 **** --- 57618,57626 ---- IsOverCutLine, WasOverCutLine, IsPopping, + + IsStretching, + IsZooming }; *************** *** 57581,57586 **** --- 57653,57663 ---- wxCursor *mAdjustLeftSelectionCursor; wxCursor *mAdjustRightSelectionCursor; + wxCursor *mStretchCursor; + wxCursor *mStretchLeftCursor; + wxCursor *mStretchRightCursor; + + wxMenu *mWaveTrackMenu; wxMenu *mNoteTrackMenu; wxMenu *mTimeTrackMenu; *************** *** 68942,68952 **** successAudio = StartPortAudioStream(sampleRate, playbackChannels, captureChannels, captureFormat); ! if (!successAudio ! ! ! ! ) { if (mListener && captureChannels > 0) mListener->OnAudioIOStopRecording(); mStreamToken = 0; --- 69025,69031 ---- successAudio = StartPortAudioStream(sampleRate, playbackChannels, captureChannels, captureFormat); ! if (!successAudio) { if (mListener && captureChannels > 0) mListener->OnAudioIOStopRecording(); mStreamToken = 0; // semantically identical *************** *** 69001,69018 **** while( mAudioThreadShouldCallFillBuffersOnce == true ) wxMilliSleep( 50 ); ! ! ! ! ! ! ! ! if(mNumPlaybackChannels > 0 || mNumCaptureChannels > 0 ! ! ! ! ) { PaError err; --- 69081,69087 ---- while( mAudioThreadShouldCallFillBuffersOnce == true ) wxMilliSleep( 50 ); ! if(mNumPlaybackChannels > 0 || mNumCaptureChannels > 0) { PaError err; // semantically identical diff -wrcB e79/src/Menus.cpp.E e80/src/Menus.cpp.E *** e79/src/Menus.cpp.E 2010-11-27 06:35:16.000000000 -0500 --- e80/src/Menus.cpp.E 2010-11-27 06:35:45.000000000 -0500 *************** *** 48698,48703 **** --- 48698,48706 ---- static bool IsGoodInt(const wxString strInt); static bool IsValidChannel(const int nValue); + + static bool IsValidVisibleChannels(const int nValue); + static bool IsValidSampleFormat(const int nValue); }; // this is from XMLTagHandler.h (again) // -- support for Channel selection button saving *************** *** 48748,48754 **** class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; --- 48751,48757 ---- class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class __attribute__((visibility("default"))) NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; // we've seen this before, as well as the following changes in allegro.h: *************** *** 52065,52070 **** --- 52071,52093 ---- bool HitTestEnvelope(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSamples(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSlide(Track *track, wxRect &r, wxMouseEvent & event); + enum StretchEnum { + stretchLeft, + stretchCenter, + stretchRight + }; + StretchEnum mStretchMode; + bool mStretching; + bool mStretched; + double mStretchStart; + + double mStretchSel0; + double mStretchSel1; + double mStretchLeftBeats; + double mStretchRightBeats; + bool HitTestStretch(Track *track, wxRect &r, wxMouseEvent & event); + void Stretch(int mouseXCoordinate, int trackLeftEdge, Track *pTrack); + void HandleSelect(wxMouseEvent & event); *************** *** 52294,52299 **** --- 52317,52326 ---- double mHSlideAmount; + + NoteTrack *mCapturedNoteClip; + + bool mDidSlideVertically; bool mRedrawAfterStop; *************** *** 52357,52362 **** --- 52384,52392 ---- IsOverCutLine, WasOverCutLine, IsPopping, + + IsStretching, + IsZooming }; *************** *** 52389,52394 **** --- 52419,52429 ---- wxCursor *mAdjustLeftSelectionCursor; wxCursor *mAdjustRightSelectionCursor; + wxCursor *mStretchCursor; + wxCursor *mStretchLeftCursor; + wxCursor *mStretchRightCursor; + + wxMenu *mWaveTrackMenu; wxMenu *mNoteTrackMenu; wxMenu *mTimeTrackMenu; *************** *** 52793,52798 **** --- 52828,52838 ---- typedef class Alg_parameter { public: + + + + + Alg_parameter() { attr = "i"; } ~Alg_parameter(); Alg_attribute attr; union { *************** *** 53095,53101 **** --- 53135,53144 ---- void insert_beat(double time, double beat); bool insert_tempo(double tempo, double beat); + double get_tempo(double beat); + bool set_tempo(double tempo, double start_beat, double end_beat); + bool stretch_region(double b0, double b1, double dur); void cut(double start, double len, bool units_are_seconds); void trim(double start, double end, bool units_are_seconds); void paste(double start, Alg_track *tr); *************** *** 53369,53379 **** void show(); long length() { return len; } int find_beat(double beat); ! void insert(double beat, double num, double den); ! void cut(double start, double end); void trim(double start, double end); void paste(double start, Alg_seq *seq); void insert_beats(double beat, double len); }; --- 53412,53426 ---- void show(); long length() { return len; } int find_beat(double beat); ! ! double get_bar_len(double beat); ! void insert(double beat, double num, double den, bool force = false); ! void cut(double start, double end, double dur); void trim(double start, double end); void paste(double start, Alg_seq *seq); void insert_beats(double beat, double len); + + double nearest_beat(double beat); }; *************** *** 53416,53426 **** --- 53463,53476 ---- typedef struct Alg_pending_event { + void *cookie; Alg_events *events; long index; bool note_on; + double offset; } *Alg_pending_event_ptr; + typedef class Alg_iterator { private: long maxlen; *************** *** 53432,53439 **** void show(); bool earlier(int i, int j); ! void insert(Alg_events_ptr events, long index, bool note_on); ! bool remove_next(Alg_events_ptr &events, long &index, bool ¬e_on); public: bool note_off_flag; --- 53482,53492 ---- void show(); bool earlier(int i, int j); ! void insert(Alg_events_ptr events, long index, bool note_on, ! void *cookie, double offset); ! ! bool remove_next(Alg_events_ptr &events, long &index, bool ¬e_on, ! void *&cookie, double &offset); public: bool note_off_flag; *************** *** 53444,53460 **** maxlen = len = 0; pending_events = __null; } - ~Alg_iterator(); - void begin(bool note_off_flag = false); ! Alg_event_ptr next(bool *note_on = __null); void end(); } *Alg_iterator_ptr; --- 53497,53515 ---- maxlen = len = 0; pending_events = __null; } + void begin_seq(Alg_seq_ptr s, void *cookie = __null, double offset = 0.0); + ~Alg_iterator(); ! void begin(void *cookie = __null) { begin_seq(seq, cookie); } ! Alg_event_ptr next(bool *note_on = __null, void **cookie_ptr = __null, ! double *offset_ptr = __null, double end_time = 0); void end(); } *Alg_iterator_ptr; *************** *** 53489,53496 **** Alg_seq(Alg_track_ref track) { seq_from_track(track); } Alg_seq(Alg_track_ptr track) { seq_from_track(*track); } void seq_from_track(Alg_track_ref tr); ! Alg_seq(std::istream &file, bool smf); ! Alg_seq(const char *filename, bool smf); virtual ~Alg_seq(); int get_read_error() { return error; } void serialize(void **buffer, long *bytes); --- 53544,53553 ---- Alg_seq(Alg_track_ref track) { seq_from_track(track); } Alg_seq(Alg_track_ptr track) { seq_from_track(*track); } void seq_from_track(Alg_track_ref tr); ! ! Alg_seq(std::istream &file, bool smf, double *offset_ptr = __null); ! ! Alg_seq(const char *filename, bool smf, double *offset_ptr = __null); virtual ~Alg_seq(); int get_read_error() { return error; } void serialize(void **buffer, long *bytes); *************** *** 53503,53511 **** void unserialize_seq(); ! void write(std::ostream &file, bool in_secs); ! bool write(const char *filename); void smf_write(std::ostream &file); bool smf_write(const char *filename); --- 53560,53568 ---- void unserialize_seq(); ! void write(std::ostream &file, bool in_secs, double offset = 0.0); ! bool write(const char *filename, double offset = 0.0); void smf_write(std::ostream &file); bool smf_write(const char *filename); *************** *** 53547,53560 **** --- 53604,53630 ---- long seek_time(double time, int track_num); bool insert_beat(double time, double beat); + + + + + + double nearest_beat_time(double time, double *beat); + bool insert_tempo(double bpm, double beat); + bool stretch_region(double b0, double b1, double dur); + void add_event(Alg_event_ptr event, int track_num); void add(Alg_event_ptr event) { (__builtin_expect(!(false), 0) ? __assert_rtn(__func__, "/Users/rbd/audacity/audacity-rNNN/lib-src/portsmf/allegro.h", NNNN, "false") : (void)0); } + double get_tempo(double beat); bool set_tempo(double bpm, double start_beat, double end_beat); + + + double get_bar_len(double beat); void set_time_sig(double beat, double num, double den); void beat_to_measure(double beat, long *measure, double *m_beat, double *num, double *den); *************** *** 70915,70920 **** --- 70994,71002 ---- float Get( bool convert = true ); void Set(float value); + void SetStyle(int style); + + void Increase(float steps); void Decrease(float steps); bool ShowDialog(wxPoint pos = wxPoint(-1, -1)); // from ASlider.h -- generalizations for EXPERIMENTAL_MIDI_OUT, mistakenly // under USE_MIDI: I changed this to eliminate this difference (but I think // this is already fixed in later revisions) *************** *** 71222,71229 **** --- 71304,71317 ---- class AudacityProject; class MixerBoard; + + + class WaveTrack; + class NoteTrack; + + class MixerTrackCluster : public wxPanel { public: // from MixerBoard.h -- should not appear under USE_MIDI, changed to // enable with EXPERIMENTAL_MIDI_OUT (but this is already corrected in // later revision) *************** *** 71271,71276 **** --- 71364,71372 ---- WaveTrack* mLeftTrack; WaveTrack* mRightTrack; + NoteTrack* mNoteTrack; + + private: MixerBoard* mMixerBoard; AudacityProject* mProject; // from MixerBoard.h -- should not appear under USE_MIDI, changed to // enable with EXPERIMENTAL_MIDI_OUT (but this is already corrected in // later revision) *************** *** 120422,120431 **** virtual int GetKind() const { return Note; } ! virtual double GetStartTime() { return 0.0; } ! virtual double GetEndTime() { return mLen; } ! void DrawLabelControls(wxDC & dc, wxRect & r); bool LabelClick(wxRect & r, int x, int y, bool right); void SetSequence(Alg_seq *seq); --- 120532,120541 ---- virtual int GetKind() const { return Note; } ! virtual double GetStartTime(); ! virtual double GetEndTime(); ! int DrawLabelControls(wxDC & dc, wxRect & r); bool LabelClick(wxRect & r, int x, int y, bool right); void SetSequence(Alg_seq *seq); // GetStartTime and GetEndTime now compute a value based on mOffset, so // they are defined in NoteTrack.cpp *************** *** 120434,120447 **** --- 120544,120607 ---- int GetVisibleChannels(); + Alg_seq_ptr MakeExportableSeq(); bool ExportMIDI(wxString f); bool ExportAllegro(wxString f); virtual bool Cut (double t0, double t1, Track **dest); virtual bool Copy (double t0, double t1, Track **dest); + virtual bool Trim (double t0, double t1); virtual bool Clear(double t0, double t1); virtual bool Paste(double t, Track *src); + virtual bool Shift(double t); + + float GetGain() const { return mGain; } + void SetGain(float gain) { mGain = gain; } + + double NearestBeatTime(double time, double *beat); + bool StretchRegion(double b0, double b1, double dur); int GetBottomNote() const { return mBottomNote; } + int GetPitchHeight() const { return mPitchHeight; } + void SetPitchHeight(int h) { mPitchHeight = h; } + void ZoomOut(int y) { Zoom(y, -1); } + void ZoomIn(int y) { Zoom(y, 1); } + void Zoom(int centerY, int amount); + void ZoomTo(int start, int end); + int GetNoteMargin() const { return (mPitchHeight + 1) / 2; } + int GetOctaveHeight() const { return mPitchHeight * 12 + 2; } + + + + void PrepareIPitchToY(const wxRect &r) { + mBottom = r.y + r.height - GetNoteMargin() - 1 - mPitchHeight + + (mBottomNote / 12) * GetOctaveHeight() + + GetNotePos(mBottomNote % 12); + } + + int IPitchToY(int p) const { + return mBottom - (p / 12) * GetOctaveHeight() - GetNotePos(p % 12); + } + + + int GetOctaveBottom(int oct) const { + return IPitchToY(oct * 12) + mPitchHeight + 1; + } + + int PitchToY(double p) const { + return IPitchToY((int) (p + 0.5)); + } + + int YToIPitch(int y); + + + + int GetNotePos(int p) const { return 1 + mPitchHeight * (p + 1) + (p > 4); } + + int GetBlackPos(int i) const { return GetNotePos(i * 2 + 1 + (i > 1)); } + + + + int GetWhitePos(int i) const { return 1 + (i * GetOctaveHeight()) / 7; } void SetBottomNote(int note) { if (note < 0) // in NoteTrack.h *************** *** 120452,120457 **** --- 120612,120628 ---- mBottomNote = note; } + + + + + + void StartVScroll(); + void VScroll(int start, int end); + + wxRect GetGainPlacementRect() const { return mGainPlacementRect; } + void SetGainPlacementRect(const wxRect &r) { mGainPlacementRect = r; } + virtual bool HandleXMLTag(const wxChar *tag, const wxChar **attrs); virtual XMLTagHandler *HandleXMLChild(const wxChar *tag); virtual void WriteXML(XMLWriter &xmlFile); // vertical scrolling in NoteTrack.h *************** *** 120460,120473 **** Alg_seq *mSeq; char *mSerializationBuffer; long mSerializationLength; - double mLen; DirManager *mDirManager; ! int mBottomNote; int mVisibleChannels; int mLastMidiPosition; }; --- 120631,120649 ---- Alg_seq *mSeq; char *mSerializationBuffer; long mSerializationLength; DirManager *mDirManager; ! float mGain; ! + int mBottom; + int mBottomNote; + int mStartBottomNote; + int mPitchHeight; int mVisibleChannels; int mLastMidiPosition; + wxRect mGainPlacementRect; }; // more in NoteTrack.h, mGain put under EXPERIMENTAL_MIDI_OUT where // it belongs *************** *** 129927,129936 **** Track *n = iter.First(); while (n) { ! if ((n->GetKind() == Track::Wave) && n->GetSelected()) { ((WaveTrack*)n)->Trim(mViewInfo.sel0, mViewInfo.sel1); } n = iter.Next(); } --- 130096,130124 ---- Track *n = iter.First(); while (n) { ! ! if (n->GetSelected()) { ! switch (n->GetKind()) ! { ! case Track::Note: ! ((NoteTrack*)n)->Trim(mViewInfo.sel0, mViewInfo.sel1); ! break; ! ! case Track::Wave: ((WaveTrack*)n)->Trim(mViewInfo.sel0, mViewInfo.sel1); + break; + + default: + break; + } } + + + + + + n = iter.Next(); } // OnTrim implementation in Menus.cpp -- not sure why this is new // Maybe it just wasn't implemented before. diff -wrcB e79/src/MixerBoard.cpp.E e80/src/MixerBoard.cpp.E *** e79/src/MixerBoard.cpp.E 2010-11-27 11:41:59.000000000 -0500 --- e80/src/MixerBoard.cpp.E 2010-11-27 11:42:28.000000000 -0500 // NOTE: NoteTrack.h was included under USE_MIDI. I changed this to // EXPERIMENTAL_MIDI_OUT (already done in later revisions). Also found // other ifdef's with USE_MIDI in Mixerboard and changed them all to // EXPERIMENTAL_MIDI_OUT. *************** *** 24676,24681 **** --- 24681,24689 ---- static bool IsGoodInt(const wxString strInt); static bool IsValidChannel(const int nValue); + + static bool IsValidVisibleChannels(const int nValue); + static bool IsValidSampleFormat(const int nValue); }; // see above. // Where does the following NoteTrack stuff come from, and should it be // in MixerBoard.cpp? Answer: NoteTrack and NoteTrackArray are declared in // Track.h *************** *** 26658,26664 **** class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; --- 26695,26701 ---- class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class __attribute__((visibility("default"))) NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; *************** *** 29319,29324 **** --- 29359,29381 ---- bool HitTestEnvelope(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSamples(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSlide(Track *track, wxRect &r, wxMouseEvent & event); + enum StretchEnum { + stretchLeft, + stretchCenter, + stretchRight + }; + StretchEnum mStretchMode; + bool mStretching; + bool mStretched; + double mStretchStart; + + double mStretchSel0; + double mStretchSel1; + double mStretchLeftBeats; + double mStretchRightBeats; + bool HitTestStretch(Track *track, wxRect &r, wxMouseEvent & event); + void Stretch(int mouseXCoordinate, int trackLeftEdge, Track *pTrack); + void HandleSelect(wxMouseEvent & event); // in TrackPanel.h *************** *** 29611,29616 **** --- 29668,29676 ---- IsOverCutLine, WasOverCutLine, IsPopping, + + IsStretching, + IsZooming }; *************** *** 29643,29648 **** --- 29703,29713 ---- wxCursor *mAdjustLeftSelectionCursor; wxCursor *mAdjustRightSelectionCursor; + wxCursor *mStretchCursor; + wxCursor *mStretchLeftCursor; + wxCursor *mStretchRightCursor; + + wxMenu *mWaveTrackMenu; wxMenu *mNoteTrackMenu; wxMenu *mTimeTrackMenu; *************** *** 52062,52067 **** --- 52127,52137 ---- typedef class Alg_parameter { public: + + + + + Alg_parameter() { attr = "i"; } ~Alg_parameter(); Alg_attribute attr; union { // NOTE: There's no reason for allegro.h to be seen by MixerBoard.cpp. // Allegro.h is included by AudioIO.h which is included by Project.h, but // allegro.h is associated with Midi output, so it should be protected by // EXPERIMENTAL_MIDI_OUT. I did this to my working copies of both r10769 // and r10680 to get rid of this and other changes. *************** *** 67595,67603 **** void MixerTrackCluster::OnButton_Solo(wxCommandEvent& event) { - mProject->HandleTrackSolo(mLeftTrack, mToggleButton_Solo->WasShiftDown()); bool bIsSolo = mLeftTrack->GetSolo(); mToggleButton_Mute->SetAlternate(bIsSolo); --- 67768,67780 ---- void MixerTrackCluster::OnButton_Solo(wxCommandEvent& event) { + + + + mProject->HandleTrackSolo(mLeftTrack, mToggleButton_Solo->WasShiftDown()); bool bIsSolo = mLeftTrack->GetSolo(); + mToggleButton_Mute->SetAlternate(bIsSolo); // no actual changes here *************** *** 67757,67771 **** while (pLeftTrack) { pRightTrack = pLeftTrack->GetLinked() ? iterTracks.Next() : __null; ! if (pLeftTrack->GetKind() == Track::Wave) ! { ! if (nClusterIndex < nClusterCount) ! { ! mMixerTrackClusters[nClusterIndex]->mLeftTrack = (WaveTrack*)pLeftTrack; mMixerTrackClusters[nClusterIndex]->mRightTrack = (WaveTrack*)pRightTrack; mMixerTrackClusters[nClusterIndex]->UpdateForStateChange(); } --- 67937,67952 ---- while (pLeftTrack) { pRightTrack = pLeftTrack->GetLinked() ? iterTracks.Next() : __null; ! if (pLeftTrack->GetKind() == Track::Wave + ) + { + if (nClusterIndex < nClusterCount) + { mMixerTrackClusters[nClusterIndex]->mLeftTrack = (WaveTrack*)pLeftTrack; + mMixerTrackClusters[nClusterIndex]->mRightTrack = (WaveTrack*)pRightTrack; mMixerTrackClusters[nClusterIndex]->UpdateForStateChange(); } // no actual change here diff -wrcB e79/src/NoteTrack.cpp.E e80/src/NoteTrack.cpp.E *** e79/src/NoteTrack.cpp.E 2010-11-27 12:45:20.000000000 -0500 --- e80/src/NoteTrack.cpp.E 2010-11-27 12:45:52.000000000 -0500 // Note: there were over 21,000 lines of diff output for NoteTrack.cpp, // which is mostly due to include files. I deleted all that from here -- // it did not seem readable and/or helpful. Even "real" or "significant" // changes if we could isolate them would be extensive and expected here. diff -wrcB e79/src/Project.cpp.E e80/src/Project.cpp.E *** e79/src/Project.cpp.E 2010-11-27 12:45:26.000000000 -0500 --- e80/src/Project.cpp.E 2010-11-27 12:45:58.000000000 -0500 *************** *** 158670,158675 **** --- 158670,158678 ---- static bool IsGoodInt(const wxString strInt); static bool IsValidChannel(const int nValue); + + static bool IsValidVisibleChannels(const int nValue); + static bool IsValidSampleFormat(const int nValue); }; *************** *** 158720,158726 **** class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; --- 158723,158729 ---- class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class __attribute__((visibility("default"))) NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; *************** *** 161227,161232 **** --- 161233,161255 ---- bool HitTestEnvelope(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSamples(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSlide(Track *track, wxRect &r, wxMouseEvent & event); + enum StretchEnum { + stretchLeft, + stretchCenter, + stretchRight + }; + StretchEnum mStretchMode; + bool mStretching; + bool mStretched; + double mStretchStart; + + double mStretchSel0; + double mStretchSel1; + double mStretchLeftBeats; + double mStretchRightBeats; + bool HitTestStretch(Track *track, wxRect &r, wxMouseEvent & event); + void Stretch(int mouseXCoordinate, int trackLeftEdge, Track *pTrack); + void HandleSelect(wxMouseEvent & event); *************** *** 161519,161524 **** --- 161542,161550 ---- IsOverCutLine, WasOverCutLine, IsPopping, + + IsStretching, + IsZooming }; *************** *** 161551,161556 **** --- 161577,161587 ---- wxCursor *mAdjustLeftSelectionCursor; wxCursor *mAdjustRightSelectionCursor; + wxCursor *mStretchCursor; + wxCursor *mStretchLeftCursor; + wxCursor *mStretchRightCursor; + + wxMenu *mWaveTrackMenu; wxMenu *mNoteTrackMenu; wxMenu *mTimeTrackMenu; *************** *** 174267,174273 **** --- 174339,175208 ---- }; // Note: allegro.h included here, I'm editing out all the inserted lines // that result *************** *** 174285,174294 **** virtual int GetKind() const { return Note; } ! virtual double GetStartTime() { return 0.0; } ! virtual double GetEndTime() { return mLen; } ! void DrawLabelControls(wxDC & dc, wxRect & r); bool LabelClick(wxRect & r, int x, int y, bool right); void SetSequence(Alg_seq *seq); --- 175220,175229 ---- virtual int GetKind() const { return Note; } ! virtual double GetStartTime(); ! virtual double GetEndTime(); ! int DrawLabelControls(wxDC & dc, wxRect & r); bool LabelClick(wxRect & r, int x, int y, bool right); void SetSequence(Alg_seq *seq); //see above *************** *** 174297,174310 **** --- 175232,175295 ---- int GetVisibleChannels(); + Alg_seq_ptr MakeExportableSeq(); bool ExportMIDI(wxString f); bool ExportAllegro(wxString f); virtual bool Cut (double t0, double t1, Track **dest); virtual bool Copy (double t0, double t1, Track **dest); + virtual bool Trim (double t0, double t1); virtual bool Clear(double t0, double t1); virtual bool Paste(double t, Track *src); + virtual bool Shift(double t); + + float GetGain() const { return mGain; } + void SetGain(float gain) { mGain = gain; } + + double NearestBeatTime(double time, double *beat); + bool StretchRegion(double b0, double b1, double dur); int GetBottomNote() const { return mBottomNote; } + int GetPitchHeight() const { return mPitchHeight; } + void SetPitchHeight(int h) { mPitchHeight = h; } + void ZoomOut(int y) { Zoom(y, -1); } + void ZoomIn(int y) { Zoom(y, 1); } + void Zoom(int centerY, int amount); + void ZoomTo(int start, int end); + int GetNoteMargin() const { return (mPitchHeight + 1) / 2; } + int GetOctaveHeight() const { return mPitchHeight * 12 + 2; } + + + + void PrepareIPitchToY(const wxRect &r) { + mBottom = r.y + r.height - GetNoteMargin() - 1 - mPitchHeight + + (mBottomNote / 12) * GetOctaveHeight() + + GetNotePos(mBottomNote % 12); + } + + int IPitchToY(int p) const { + return mBottom - (p / 12) * GetOctaveHeight() - GetNotePos(p % 12); + } + + + int GetOctaveBottom(int oct) const { + return IPitchToY(oct * 12) + mPitchHeight + 1; + } + + int PitchToY(double p) const { + return IPitchToY((int) (p + 0.5)); + } + + int YToIPitch(int y); + + + + int GetNotePos(int p) const { return 1 + mPitchHeight * (p + 1) + (p > 4); } + + int GetBlackPos(int i) const { return GetNotePos(i * 2 + 1 + (i > 1)); } + + + + int GetWhitePos(int i) const { return 1 + (i * GetOctaveHeight()) / 7; } void SetBottomNote(int note) { if (note < 0) // GetGain and SetGain are not needed unless there is EXPERIMENTAL_MIDI_OUT, // so I put them under ifdef control. *************** *** 174315,174320 **** --- 175300,175316 ---- mBottomNote = note; } + + + + + + void StartVScroll(); + void VScroll(int start, int end); + + wxRect GetGainPlacementRect() const { return mGainPlacementRect; } + void SetGainPlacementRect(const wxRect &r) { mGainPlacementRect = r; } + virtual bool HandleXMLTag(const wxChar *tag, const wxChar **attrs); virtual XMLTagHandler *HandleXMLChild(const wxChar *tag); virtual void WriteXML(XMLWriter &xmlFile); // GetGainPlacementRect and SetGainPlacementRect should be under // EXPERIMENTAL_MIDI_OUT, so I put them there *************** *** 174323,174336 **** Alg_seq *mSeq; char *mSerializationBuffer; long mSerializationLength; - double mLen; DirManager *mDirManager; ! int mBottomNote; int mVisibleChannels; int mLastMidiPosition; }; class wxArrayString; --- 175319,175337 ---- Alg_seq *mSeq; char *mSerializationBuffer; long mSerializationLength; DirManager *mDirManager; ! float mGain; ! + int mBottom; + int mBottomNote; + int mStartBottomNote; + int mPitchHeight; int mVisibleChannels; int mLastMidiPosition; + wxRect mGainPlacementRect; }; class wxArrayString; // see above, mGain now under EXPERIMENTAL_MIDI_OUT *************** *** 189245,189250 **** --- 190246,190252 ---- { + ; wxString projName; if (mFileName.IsEmpty()) // related to redisplay sonification, semantically identical *************** *** 189300,189305 **** --- 190302,190308 ---- mAutoSaveFileName += fn + L".autosave"; mLastAutoSaveTime = wxGetLocalTime(); + ; } void AudacityProject::DeleteCurrentAutoSaveFile() // related to redisplay sonification, semantically identical diff -wrcB e79/src/Snap.cpp.E e80/src/Snap.cpp.E *** e79/src/Snap.cpp.E 2010-11-27 12:45:28.000000000 -0500 --- e80/src/Snap.cpp.E 2010-11-27 12:45:59.000000000 -0500 *************** *** 14434,14439 **** --- 14434,14442 ---- static bool IsGoodInt(const wxString strInt); static bool IsValidChannel(const int nValue); + + static bool IsValidVisibleChannels(const int nValue); + static bool IsValidSampleFormat(const int nValue); }; // see above *************** *** 14484,14490 **** class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; --- 14487,14493 ---- class NoteTrack; ! typedef NoteTrack* _wxArrayNoteTrackArray; struct wxAssert_NoteTrackArray { unsigned int TypeTooBigToBeStoredInwxBaseArrayPtrVoid: sizeof(_wxArrayNoteTrackArray) <= sizeof(wxBaseArrayPtrVoid::base_type); }; typedef int ( *CMPFUNC_wxArrayNoteTrackArray)(_wxArrayNoteTrackArray *pItem1, _wxArrayNoteTrackArray *pItem2); class __attribute__((visibility("default"))) NoteTrackArray : public wxBaseArrayPtrVoid { public: NoteTrackArray() { } ~NoteTrackArray() { } NoteTrackArray& operator=(const NoteTrackArray& src) { wxBaseArrayPtrVoid* temp = (wxBaseArrayPtrVoid*) this; (*temp) = ((const wxBaseArrayPtrVoid&)src); return *this; } _wxArrayNoteTrackArray& operator[](size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Item(size_t uiIndex) const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](uiIndex)); } _wxArrayNoteTrackArray& Last() const { return (_wxArrayNoteTrackArray&)(wxBaseArrayPtrVoid::operator[](Count() - 1)); } int Index(_wxArrayNoteTrackArray lItem, bool bFromEnd = false) const { return wxBaseArrayPtrVoid::Index((base_type)lItem, bFromEnd); } void Add(_wxArrayNoteTrackArray lItem, size_t nInsert = 1) { wxBaseArrayPtrVoid::Add((base_type)lItem, nInsert); } void Insert(_wxArrayNoteTrackArray lItem, size_t uiIndex, size_t nInsert = 1) { wxBaseArrayPtrVoid::Insert((base_type)lItem, uiIndex, nInsert) ; } void RemoveAt(size_t uiIndex, size_t nRemove = 1) { wxBaseArrayPtrVoid::RemoveAt(uiIndex, nRemove); } void Remove(_wxArrayNoteTrackArray lItem) { int iIndex = Index(lItem); if ( iIndex != (-1) ) ; else { wxOnAssert(L"/Users/rbd/audacity/wNN/src/Track.h", NNNN, __FUNCTION__, L"iIndex != wxNOT_FOUND", L"removing inexisting element in wxArray::Remove"); return; } typedef int wxDummyCheckInt; wxBaseArrayPtrVoid::RemoveAt((size_t)iIndex); } void Sort(CMPFUNC_wxArrayNoteTrackArray fCmp) { wxBaseArrayPtrVoid::Sort((CMPFUNC)fCmp); } private: typedef wxBaseArrayPtrVoid::iterator biterator; typedef wxBaseArrayPtrVoid::const_iterator bconst_iterator; typedef wxBaseArrayPtrVoid::value_type bvalue_type; typedef wxBaseArrayPtrVoid::const_reference bconst_reference; public: typedef _wxArrayNoteTrackArray value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type* iterator; typedef const value_type* const_iterator; typedef value_type& reference; typedef const value_type& const_reference; typedef wxBaseArrayPtrVoid::difference_type difference_type; typedef wxBaseArrayPtrVoid::size_type size_type; class reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef value_type& reference; typedef value_type* pointer; typedef reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; reverse_iterator() : m_ptr(__null) { } reverse_iterator(pointer ptr) : m_ptr(ptr) { } reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { reverse_iterator tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; class const_reverse_iterator { typedef _wxArrayNoteTrackArray value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef const_reverse_iterator itor; friend inline itor operator+(int o, const itor& it) { return it.m_ptr - o; } friend inline itor operator+(const itor& it, int o) { return it.m_ptr - o; } friend inline itor operator-(const itor& it, int o) { return it.m_ptr + o; } friend inline difference_type operator-(const itor& i1, const itor& i2) { return i1.m_ptr - i2.m_ptr; } public: pointer m_ptr; const_reverse_iterator() : m_ptr(__null) { } const_reverse_iterator(pointer ptr) : m_ptr(ptr) { } const_reverse_iterator(const itor& it) : m_ptr(it.m_ptr) { } const_reverse_iterator(const reverse_iterator& it) : m_ptr(it.m_ptr) { } reference operator*() const { return *m_ptr; } pointer operator->() const { return m_ptr; } itor& operator++() { --m_ptr; return *this; } const itor operator++(int) { itor tmp = *this; --m_ptr; return tmp; } itor& operator--() { ++m_ptr; return *this; } const itor operator--(int) { itor tmp = *this; ++m_ptr; return tmp; } bool operator ==(const itor& it) const { return m_ptr == it.m_ptr; } bool operator !=(const itor& it) const { return m_ptr != it.m_ptr; } }; NoteTrackArray(size_type n, const_reference v) { assign(n, v); } NoteTrackArray(const_iterator first, const_iterator last) { assign(first, last); } void assign(const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::assign((bconst_iterator)first, (bconst_iterator)last); } void assign(size_type n, const_reference v) { wxBaseArrayPtrVoid::assign(n, (bconst_reference)v); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } iterator begin() { return (iterator)wxBaseArrayPtrVoid::begin(); } const_iterator begin() const { return (const_iterator)wxBaseArrayPtrVoid::begin(); } size_type capacity() const { return wxBaseArrayPtrVoid::capacity(); } iterator end() { return (iterator)wxBaseArrayPtrVoid::end(); } const_iterator end() const { return (const_iterator)wxBaseArrayPtrVoid::end(); } iterator erase(iterator first, iterator last) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)first, (biterator)last); } iterator erase(iterator it) { return (iterator)wxBaseArrayPtrVoid::erase((biterator)it); } reference front() { return *begin(); } const_reference front() const { return *begin(); } void insert(iterator it, size_type n, const_reference v) { wxBaseArrayPtrVoid::insert((biterator)it, n, (bconst_reference)v); } iterator insert(iterator it, const_reference v = value_type()) { return (iterator)wxBaseArrayPtrVoid::insert((biterator)it, (bconst_reference)v); } void insert(iterator it, const_iterator first, const_iterator last) { wxBaseArrayPtrVoid::insert((biterator)it, (bconst_iterator)first, (bconst_iterator)last); } void pop_back() { wxBaseArrayPtrVoid::pop_back(); } void push_back(const_reference v) { wxBaseArrayPtrVoid::push_back((bconst_reference)v); } reverse_iterator rbegin() { return reverse_iterator(end() - 1); } const_reverse_iterator rbegin() const; reverse_iterator rend() { return reverse_iterator(begin() - 1); } const_reverse_iterator rend() const; void reserve(size_type n) { wxBaseArrayPtrVoid::reserve(n); } void resize(size_type n, value_type v = value_type()) { wxBaseArrayPtrVoid::resize(n, v); } }; class TrackList; // see above *************** *** 25648,25653 **** --- 25654,25676 ---- bool HitTestEnvelope(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSamples(Track *track, wxRect &r, wxMouseEvent & event); bool HitTestSlide(Track *track, wxRect &r, wxMouseEvent & event); + enum StretchEnum { + stretchLeft, + stretchCenter, + stretchRight + }; + StretchEnum mStretchMode; + bool mStretching; + bool mStretched; + double mStretchStart; + + double mStretchSel0; + double mStretchSel1; + double mStretchLeftBeats; + double mStretchRightBeats; + bool HitTestStretch(Track *track, wxRect &r, wxMouseEvent & event); + void Stretch(int mouseXCoordinate, int trackLeftEdge, Track *pTrack); + void HandleSelect(wxMouseEvent & event); // see above *************** *** 25940,25945 **** --- 25963,25971 ---- IsOverCutLine, WasOverCutLine, IsPopping, + + IsStretching, + IsZooming }; // see above *************** *** 25972,25977 **** --- 25998,26008 ---- wxCursor *mAdjustLeftSelectionCursor; wxCursor *mAdjustRightSelectionCursor; + wxCursor *mStretchCursor; + wxCursor *mStretchLeftCursor; + wxCursor *mStretchRightCursor; + + wxMe