Menu
▾
▴
jazzplusplus-updates
|
From: <pst...@us...> - 2008-03-21 06:10:30
|
Revision: 348
http://jazzplusplus.svn.sourceforge.net/jazzplusplus/?rev=348&view=rev
Author: pstieber
Date: 2008-03-20 23:10:27 -0700 (Thu, 20 Mar 2008)
Log Message:
-----------
Fixed initializer list order.
Modified Paths:
--------------
trunk/jazz/src/PianoWindow.cpp
Modified: trunk/jazz/src/PianoWindow.cpp
===================================================================
--- trunk/jazz/src/PianoWindow.cpp 2008-03-21 05:59:20 UTC (rev 347)
+++ trunk/jazz/src/PianoWindow.cpp 2008-03-21 06:10:27 UTC (rev 348)
@@ -554,9 +554,11 @@
long WindowStyle)
: wxScrolledWindow(pPianoFrame, wxID_ANY, Position, Size, WindowStyle),
mpPianoFrame(pPianoFrame),
+ mpSong(pSong),
mPlayClock(-1),
mSnapCount(0),
- mpSong(pSong),
+ mpMouseAction(0),
+ mpSnapSel(0),
mpTrack(0),
mTrackIndex(0),
mpFilter(0),
@@ -583,9 +585,7 @@
mpFixedFont(0),
mFixedFontHeight(0),
mpDrumFont(0),
- mpSnapSel(0),
mSnapDenomiator(16),
- mpMouseAction(0),
mVisibleKeyOn(true),
mVisiblePitch(false),
mVisibleController(false),
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <pst...@us...> - 2008-04-08 23:58:18
|
Revision: 447
http://jazzplusplus.svn.sourceforge.net/jazzplusplus/?rev=447&view=rev
Author: pstieber
Date: 2008-04-08 16:58:16 -0700 (Tue, 08 Apr 2008)
Log Message:
-----------
Changed PrepareDC to DoPrepareDC and made some cosmetic changes.
Modified Paths:
--------------
trunk/jazz/src/PianoWindow.cpp
Modified: trunk/jazz/src/PianoWindow.cpp
===================================================================
--- trunk/jazz/src/PianoWindow.cpp 2008-04-08 23:56:56 UTC (rev 446)
+++ trunk/jazz/src/PianoWindow.cpp 2008-04-08 23:58:16 UTC (rev 447)
@@ -228,7 +228,7 @@
wxClientDC Dc(Win);
// to translate scrolled coordinates
- Win->PrepareDC(Dc);
+ Win->DoPrepareDC(Dc);
Win->DrawEvent(Dc, Copy, wxWHITE_BRUSH, 0);
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 1, 1);
@@ -250,7 +250,7 @@
int tKeyLengthDragger::Dragging(wxMouseEvent& Event)
{
wxClientDC Dc(Win);
- Win->PrepareDC(Dc); //to translate scrolled coordinates
+ Win->DoPrepareDC(Dc); //to translate scrolled coordinates
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 1, 1);
int fx, fy;
Win->LogicalMousePosition(Event, fx, fy);
@@ -339,7 +339,7 @@
Win->GetSong()->NewUndoBuffer();
//
wxClientDC Dc(Win);
- Win->PrepareDC(Dc);
+ Win->DoPrepareDC(Dc);
Win->DrawEvent(Dc, Copy, wxWHITE_BRUSH, 0);
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 1, 1);
}
@@ -360,7 +360,7 @@
int tPlayTrackLengthDragger::Dragging(wxMouseEvent& Event)
{
wxClientDC Dc(Win);
- Win->PrepareDC(Dc);
+ Win->DoPrepareDC(Dc);
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 1, 1);
int fx, fy;
Win->LogicalMousePosition(Event, fx, fy);
@@ -377,7 +377,7 @@
int tPlayTrackLengthDragger::ButtonUp(wxMouseEvent& Event)
{
wxClientDC Dc(Win);
- Win->PrepareDC(Dc);
+ Win->DoPrepareDC(Dc);
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 1, 1);
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 0, 1);
@@ -437,7 +437,7 @@
Win->ApplyToTrack(mpKeyOn, Copy);
wxClientDC Dc(Win);
- Win->PrepareDC(Dc);
+ Win->DoPrepareDC(Dc);
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 0, 1);
Win->UpdateControl();
@@ -1753,7 +1753,9 @@
int x;
int y;
LogicalMousePosition(Event, x, y);
- if (mEventsX < x && x < mEventsX + mEventsWidth && mEventsY < y && y < mEventsY + mEventsHeight)
+ if (
+ mEventsX < x && x < mEventsX + mEventsWidth &&
+ mEventsY < y && y < mEventsY + mEventsHeight)
{
if (Event.LeftDown())
{
@@ -1762,7 +1764,9 @@
if (mpSnapSel->Selected)
{
- Refresh(); //redraw the whole window instead(inefficient, we should rather invalidate a rect)
+ // Redraw the whole window instead (inefficient, we should rather
+ // invalidate a rect).
+ Refresh();
}
mpSnapSel->Event(Event);
mpMouseAction = mpSnapSel;
@@ -1781,7 +1785,10 @@
if (mpMouseAction == mpSnapSel)
{
SnapSelStop(Event);
- Refresh(); //ineficcient, invalidate rect first instead
+
+ // inefficient, invalidate rect first instead.
+ Refresh();
+
mpMouseAction = 0;
return 1;
}
@@ -1792,11 +1799,14 @@
return 0;
}
+//-----------------------------------------------------------------------------
+// Description:
// Indicate which key on the pianoroll that the mouse is hovering over by
// highlighting it. This function is bad because it draws directly in the dc,
// rather it should invalidate and let OnDraw do the actual painting.
// Currently the code doesn't work because it doesn't care about scrolling
// (because I get the dc the wrong way).
+//-----------------------------------------------------------------------------
void JZPianoWindow::ShowPitch(int Pitch)
{
// This is the current position of the mouse. mMouseLine is the last
@@ -1807,7 +1817,7 @@
wxClientDC Dc(this);
// Translate scrolled coordinates.
- PrepareDC(Dc);
+ DoPrepareDC(Dc);
Dc.SetLogicalFunction(wxXOR);
@@ -1875,7 +1885,7 @@
{
wxClientDC Dc(this);
- PrepareDC(Dc);
+ DoPrepareDC(Dc);
// Convert physical coordinates to logical (scrolled) coordinates.
wxPoint Point = Event.GetLogicalPosition(Dc);
@@ -2660,7 +2670,7 @@
}
wxClientDC Dc(this);
- PrepareDC(Dc);
+ DoPrepareDC(Dc);
DrawEvent(Dc, pEvent, wxWHITE_BRUSH, 0);
pTrack->Kill(pEvent);
pTrack->Cleanup();
@@ -2745,7 +2755,7 @@
}
}
wxClientDC Dc(this);
- PrepareDC(Dc);
+ DoPrepareDC(Dc);
DrawEvent(Dc, c, c->GetBrush(), 0, 1);
pTrack->Put(c);
pEvent = Iterator.Next();
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
|
From: <pst...@us...> - 2008-04-09 00:20:14
|
Revision: 448
http://jazzplusplus.svn.sourceforge.net/jazzplusplus/?rev=448&view=rev
Author: pstieber
Date: 2008-04-08 17:20:13 -0700 (Tue, 08 Apr 2008)
Log Message:
-----------
Made cosmetic changes.
Modified Paths:
--------------
trunk/jazz/src/PianoWindow.cpp
Modified: trunk/jazz/src/PianoWindow.cpp
===================================================================
--- trunk/jazz/src/PianoWindow.cpp 2008-04-08 23:58:16 UTC (rev 447)
+++ trunk/jazz/src/PianoWindow.cpp 2008-04-09 00:20:13 UTC (rev 448)
@@ -45,13 +45,10 @@
using namespace std;
-
-
-
-
//*****************************************************************************
//*****************************************************************************
-
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
JZListen::JZListen()
: mActive(false),
mPitch(-1),
@@ -60,6 +57,8 @@
{
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZListen::KeyOn(
JZTrack* pTrack,
int Pitch,
@@ -79,6 +78,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZListen::Notify()
{
Stop();
@@ -104,19 +105,22 @@
JZPianoWindow* mpPianoWindow;
};
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
tMousePlay::tMousePlay(JZPianoWindow* pPianoWindow, wxMouseEvent& Event)
: mPitch(0),
mVeloc(-1),
mChannel(-1),
mpPianoWindow(pPianoWindow)
{
- mChannel =
- mpPianoWindow->GetTrack()->Channel ? mpPianoWindow->GetTrack()->Channel - 1 : 0;
+ mChannel = mpPianoWindow->GetTrack()->Channel ?
+ mpPianoWindow->GetTrack()->Channel - 1 : 0;
ProcessEvent(Event);
}
-
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int tMousePlay::ProcessEvent(wxMouseEvent& Event)
{
int x, y;
@@ -185,12 +189,6 @@
return 0;
}
-
-
-
-
-
-
//*****************************************************************************
// Description:
// tKeyLengthDragger
@@ -199,7 +197,7 @@
{
public:
- tKeyLengthDragger(tKeyOn *k, JZPianoWindow *w);
+ tKeyLengthDragger(tKeyOn* k, JZPianoWindow* pPianoWindow);
int Dragging(wxMouseEvent& Event);
@@ -215,12 +213,13 @@
JZTrack* mpTrack;
};
-
-tKeyLengthDragger::tKeyLengthDragger(tKeyOn *k, JZPianoWindow *w)
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+tKeyLengthDragger::tKeyLengthDragger(tKeyOn* k, JZPianoWindow* pPianoWindow)
{
mpKeyOn = k;
Copy = k->Copy() -> IsKeyOn();
- Win = w;
+ Win = pPianoWindow;
// SN++ BUG FIX: undo/redo
Win->GetSong()->NewUndoBuffer();
@@ -234,6 +233,8 @@
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 1, 1);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int tKeyLengthDragger::Event(wxMouseEvent& Event)
{
if (Event.Dragging())
@@ -247,6 +248,8 @@
return 0;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int tKeyLengthDragger::Dragging(wxMouseEvent& Event)
{
wxClientDC Dc(Win);
@@ -266,6 +269,8 @@
return 0;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int tKeyLengthDragger::ButtonUp(wxMouseEvent& Event)
{
// SN++ Key_Aftertouch
@@ -308,7 +313,6 @@
return 0;
}
-
//*****************************************************************************
// Description:
// tPlayTrackLengthDragger JAVE this is just copied from tKeyLengthDragger,
@@ -322,18 +326,21 @@
JZTrack* mpTrack;
public:
- tPlayTrackLengthDragger(tPlayTrack *k, JZPianoWindow *w);
+ tPlayTrackLengthDragger(tPlayTrack *k, JZPianoWindow* pPianoWindow);
int Dragging(wxMouseEvent& Event);
int ButtonUp(wxMouseEvent& Event);
int Event(wxMouseEvent& Event);
};
-
-tPlayTrackLengthDragger::tPlayTrackLengthDragger(tPlayTrack *k, JZPianoWindow *w)
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+tPlayTrackLengthDragger::tPlayTrackLengthDragger(
+ tPlayTrack* k,
+ JZPianoWindow* pPianoWindow)
{
mpKeyOn = k;
Copy = k->Copy() -> IsPlayTrack();
- Win = w;
+ Win = pPianoWindow;
// SN++ BUG FIX: undo/redo
Win->GetSong()->NewUndoBuffer();
@@ -344,6 +351,8 @@
Win->DrawEvent(Dc, Copy, Copy->GetBrush(), 1, 1);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int tPlayTrackLengthDragger::Event(wxMouseEvent& Event)
{
if (Event.Dragging())
@@ -357,6 +366,8 @@
return 0;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int tPlayTrackLengthDragger::Dragging(wxMouseEvent& Event)
{
wxClientDC Dc(Win);
@@ -374,6 +385,8 @@
return 0;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int tPlayTrackLengthDragger::ButtonUp(wxMouseEvent& Event)
{
wxClientDC Dc(Win);
@@ -395,20 +408,19 @@
return 0;
}
-
-
-// --------------------------------------------------------------------
-// VelocCounter
-// --------------------------------------------------------------------
-
+//*****************************************************************************
+//*****************************************************************************
class tVelocCounter : public tMouseCounter
{
public:
int Event(wxMouseEvent& Event);
- tVelocCounter(JZPianoWindow *w, JZRectangle* r, tKeyOn* pEvent)
- : tMouseCounter(w, r, pEvent->Veloc, 1, 127)
+ tVelocCounter(
+ JZPianoWindow* pPianoWindow,
+ JZRectangle* r,
+ tKeyOn* pEvent)
+ : tMouseCounter(pPianoWindow, r, pEvent->Veloc, 1, 127)
{
- Win = w;
+ Win = pPianoWindow;
mpKeyOn = pEvent;
// SN++ BUG FIX: undo/redo
@@ -425,8 +437,8 @@
tKeyOn* mpKeyOn;
};
-
-
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int tVelocCounter::Event(wxMouseEvent& Event)
{
if (tMouseCounter::Event(Event))
@@ -460,6 +472,8 @@
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
static int mPianoFontSizes[] =
{
6, // Tiny
@@ -470,6 +484,8 @@
-1, // End of list
};
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
const int isBlack[12] =
{
0,
@@ -486,9 +502,13 @@
0
};
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
#define IsBlack(Key) isBlack[(Key) % 12]
+//-----------------------------------------------------------------------------
// Mouse Actions Mapping
+//-----------------------------------------------------------------------------
enum
{
MA_PLAY = 1, // 0 represents no action.
@@ -503,6 +523,8 @@
MA_VELOCITY
};
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
const int play_actions[12] =
{
// left middle right
@@ -512,6 +534,8 @@
0, 0, 0 // shift+ctrl
};
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
const int evnt_actions[12] =
{
// left middle right
@@ -842,10 +866,14 @@
int x = Clock2x(start);
if (x < mEventsX) // clip to left border
+ {
x = mEventsX;
+ }
int w = Clock2x(stop) - x;
if (w <= 0)
+ {
continue;
+ }
int h = mTrackHeight;
for (int i = 0; i < 12; i++)
@@ -925,9 +953,11 @@
DrawPlayPosition(Dc);
}
+//-----------------------------------------------------------------------------
// Decription:
// Draw the "play position", by placing a vertical line where the
// "play clock" is.
+//-----------------------------------------------------------------------------
void JZPianoWindow::DrawPlayPosition(wxDC& Dc)
{
if (!mpSnapSel->Active && mPlayClock >= mFromClock && mPlayClock < mToClock)
@@ -946,6 +976,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::OnEventWinPaintSub(int x, int y)
{
mCanvasX = x;
@@ -997,7 +1029,6 @@
}
}
-
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool JZPianoWindow::OnKeyEvent(wxKeyEvent& Event)
@@ -1054,6 +1085,8 @@
return false;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::NewPosition(int TrackIndex, int Clock)
{
mFromLines[mTrackIndex] = mFromLine;
@@ -1105,11 +1138,11 @@
return Line * mTrackHeight + mTopInfoHeight;
}
-// ********************************************************************
+//=============================================================================
// Painting
-// ********************************************************************
-
-
+//=============================================================================
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::DrawPianoRoll(wxDC& Dc)
{
// Draw the grey background for the keyboard.
@@ -1247,6 +1280,8 @@
Dc.SetFont(*mpFont);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::DrawEvent(
wxDC& Dc,
JZEvent* pEvent,
@@ -1302,6 +1337,8 @@
Dc.SetBrush(*wxBLACK_BRUSH);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::DrawEvents(
wxDC& Dc,
JZTrack *t,
@@ -1421,8 +1458,10 @@
// Dc.DestroyClippingRegion();
}
+//-----------------------------------------------------------------------------
// Draws the a 3D button with text in it. Used to draw the little area in the
// top left of the window.
+//-----------------------------------------------------------------------------
void JZPianoWindow::LineText(
wxDC& Dc,
int x,
@@ -1556,10 +1595,9 @@
}
}
-
-// ------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
// Snapper
-// ------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::SnapSelStop(wxMouseEvent& Event)
{
if (mpSnapSel->Selected)
@@ -1613,6 +1651,8 @@
mpCtrlEdit->UpDate();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::SnapSelStart(wxMouseEvent &)
{
mSnapCount = 0;
@@ -1637,6 +1677,8 @@
mTrackHeight);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::SnapClock(int Clock, int up)
{
int qnt = SnapClocks();
@@ -1648,6 +1690,8 @@
return Clock;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::NewPlayPosition(int Clock)
{
int scroll_clock = (mFromClock + 5 * mToClock) / 6L;
@@ -1689,6 +1733,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::EventsSelected(const char *msg)
{
if (!mpSnapSel->Selected)
@@ -1701,6 +1747,8 @@
return 1;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::ZoomIn()
{
if (mClockTicsPerPixel >= 2)
@@ -1722,6 +1770,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::ZoomOut()
{
if (mClockTicsPerPixel <= 120)
@@ -1743,7 +1793,8 @@
}
}
-
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::OnEventWinMouseEvent(wxMouseEvent& Event)
{
if (!mpMouseAction)
@@ -1844,11 +1895,15 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::x2Clock(int x)
{
return (x - mEventsX) * mClockTicsPerPixel + mFromClock;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::y2Line(int y, int up)
{
if (up)
@@ -1859,6 +1914,8 @@
return y / mTrackHeight;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::x2BarClock(int x, int next)
{
int clk = x2Clock(x);
@@ -1869,6 +1926,8 @@
return b.Clock;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::y2yLine(int y, int up)
{
if (up)
@@ -1881,6 +1940,8 @@
return y;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::MouseCutPaste(wxMouseEvent& Event, bool Cut)
{
wxClientDC Dc(this);
@@ -1909,6 +1970,8 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::MouseEvents(wxMouseEvent& Event)
{
int action = mMouseEvent.Action(Event);
@@ -2004,6 +2067,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::MousePiano(wxMouseEvent& Event)
{
if (Event.ButtonDown())
@@ -2042,10 +2107,11 @@
LineText(Dc, 0, 0, mPianoWidth, mTopInfoHeight, Text, IsButtonDown);
}
-//*****************************************************************************
+//=============================================================================
// Visible
-//*****************************************************************************
-
+//=============================================================================
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::IsVisible(JZEvent* pEvent)
{
switch (pEvent->Stat)
@@ -2074,6 +2140,8 @@
return 0;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::IsVisible(JZTrack* pTrack)
{
if (!mVisibleAllTracks)
@@ -2090,6 +2158,8 @@
// Utilities
// ********************************************************************
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::SnapClocks()
{
int clk = mpSong->TicksPerQuarter * 4L / mSnapDenomiator;
@@ -2098,6 +2168,8 @@
return clk;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::SetSnapDenom(int Value)
{
const int Size = 4;
@@ -2130,6 +2202,8 @@
// mMouseEvent.SetLeftAction(MA_CUTPASTE);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::y2Pitch(int y)
{
int pitch = 127 - y2Line(y);
@@ -2140,15 +2214,17 @@
return pitch;
}
-
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::Pitch2y(int Pitch)
{
return Line2y(127 - Pitch);
}
-
+//-----------------------------------------------------------------------------
+// If Pitch == -1: search for any pitches.
+//-----------------------------------------------------------------------------
JZEvent *JZPianoWindow::FindEvent(JZTrack* pTrack, int Clock, int Pitch)
-// Pitch == -1: search for any pitches
{
tEventIterator Iterator(pTrack);
JZEvent* pEvent = Iterator.First();
@@ -2172,7 +2248,8 @@
return 0;
}
-
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::kill_keys_aftertouch(JZTrack *t, JZEvent* pEvent)
{
int key,channel;
@@ -2204,6 +2281,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::paste_keys_aftertouch(JZTrack *t, JZEvent* pEvent)
{
int key,channel;
@@ -2229,12 +2308,16 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::Clock2x(int Clock)
{
return mEventsX + (Clock - mFromClock) / mClockTicsPerPixel;
}
+//-----------------------------------------------------------------------------
// show the guitar edit window.
+//-----------------------------------------------------------------------------
void JZPianoWindow::CreateGuitarWindow()
{
if (!mpGuitarFrame)
@@ -2244,6 +2327,8 @@
mpGuitarFrame->Show(true);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::UpdateControl()
{
if (mpCtrlEdit)
@@ -2252,6 +2337,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::ApplyToTrack(JZEvent* pEvent1, JZEvent* pEvent2)
{
mpTrack->Kill(pEvent1);
@@ -2259,16 +2346,22 @@
mpTrack->Cleanup();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::KillTrackEvent(JZEvent* pEvent)
{
mpTrack->Kill(pEvent);
}
+//-----------------------------------------------------------------------------
// positions for controller editor
+//-----------------------------------------------------------------------------
#define CtrlH(h) ((h)/4)
#define CtrlY(h) (h - CtrlH(h))
+//-----------------------------------------------------------------------------
// Activate velocity edit.
+//-----------------------------------------------------------------------------
void JZPianoWindow::CtrlVelocity()
{
int Width, Height;
@@ -2290,6 +2383,8 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::CtrlChannelAftertouchEdit()
{
int Width, Height;
@@ -2310,6 +2405,8 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::CtrlPolyAftertouchEdit()
{
int Width, Height;
@@ -2330,6 +2427,8 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::CtrlNone()
{
delete mpCtrlEdit;
@@ -2337,6 +2436,8 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::CtrlTempo()
{
tEventIterator Iterator(mpTrack);
@@ -2399,11 +2500,15 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::EditFilter()
{
mpFilter->Dialog(0);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::SelectController()
{
int i = SelectControllerDlg();
@@ -2429,6 +2534,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::CtrlModulation()
{
int Width, Height;
@@ -2450,6 +2557,8 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::CtrlPitch()
{
int Width, Height;
@@ -2470,6 +2579,8 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::Redo()
{
mpSong->Redo();
@@ -2480,7 +2591,9 @@
}
}
+//-----------------------------------------------------------------------------
// Undo actions
+//-----------------------------------------------------------------------------
void JZPianoWindow::Undo()
{
mpSong->Undo();
@@ -2491,7 +2604,9 @@
}
}
+//-----------------------------------------------------------------------------
// Quantize selected events.
+//-----------------------------------------------------------------------------
void JZPianoWindow::Quantize()
{
if (EventsSelected())
@@ -2502,7 +2617,9 @@
}
}
+//-----------------------------------------------------------------------------
// Flip events up and down.
+//-----------------------------------------------------------------------------
void JZPianoWindow::ExchangeUpDown()
{
if (EventsSelected())
@@ -2513,7 +2630,9 @@
}
}
+//-----------------------------------------------------------------------------
// Flip events left to right.
+//-----------------------------------------------------------------------------
void JZPianoWindow::ExchangeLeftRight()
{
if (EventsSelected())
@@ -2524,7 +2643,9 @@
}
}
+//-----------------------------------------------------------------------------
// Shift events snapclock clocks to left.
+//-----------------------------------------------------------------------------
void JZPianoWindow::ShiftLeft()
{
if (EventsSelected())
@@ -2536,7 +2657,9 @@
}
}
+//-----------------------------------------------------------------------------
// Shift events snapclock clocks to right.
+//-----------------------------------------------------------------------------
void JZPianoWindow::ShiftRight()
{
if (EventsSelected())
@@ -2548,7 +2671,9 @@
}
}
+//-----------------------------------------------------------------------------
// helper for cut and copy events
+//-----------------------------------------------------------------------------
void JZPianoWindow::CutOrCopy(int Id)
{
if (EventsSelected())
@@ -2572,6 +2697,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::Erase()
{
if (EventsSelected())
@@ -2582,6 +2709,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::ToggleVisibleAllTracks()
{
mVisibleAllTracks = !mVisibleAllTracks;
@@ -2589,54 +2718,72 @@
Refresh();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::MSelect()
{
mpPianoFrame->PressRadio(ID_SELECT);
mMouseEvent.SetLeftAction(MA_SELECT);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::MLength()
{
mpPianoFrame->PressRadio(ID_CHANGE_LENGTH);
mMouseEvent.SetLeftAction(MA_LENGTH);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::MDialog()
{
mpPianoFrame->PressRadio(ID_EVENT_DIALOG);
mMouseEvent.SetLeftAction(MA_DIALOG);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::MCutPaste()
{
mpPianoFrame->PressRadio(ID_CUT_PASTE_EVENTS);
mMouseEvent.SetLeftAction(MA_CUTPASTE);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::Snap8()
{
mPasteBuffer.Clear();
SetSnapDenom(8);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::Snap8D()
{
mPasteBuffer.Clear();
SetSnapDenom(12);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::Snap16()
{
mPasteBuffer.Clear();
SetSnapDenom(16);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::Snap16D()
{
mPasteBuffer.Clear();
SetSnapDenom(24);
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::Copy(JZTrack* pTrack, JZEvent* pEvent, int Kill)
{
if (!pEvent)
@@ -2689,7 +2836,8 @@
}
}
-
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::Paste(JZTrack* pTrack, int Clock, int Pitch)
{
if (mPasteBuffer.nEvents == 0)
@@ -2769,6 +2917,8 @@
}
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::GetKeyOnEventCount()
{
int Count = 0;
@@ -2786,23 +2936,31 @@
return Count;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
int JZPianoWindow::Channel()
{
return mpTrack->Channel ? mpTrack->Channel - 1 : 0;
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::SnapDialog()
{
tSnapDlg* pSnapDialog = new tSnapDlg(this, &mSnapDenomiator);
pSnapDialog->Create();
}
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
void JZPianoWindow::SetVisibleAllTracks(bool Value)
{
mVisibleAllTracks = Value;
Refresh();
}
+//-----------------------------------------------------------------------------
+//---...
[truncated message content] |
Thanks for helping keep SourceForge clean.
X