// Constructor.
qtractorPluginParamCommand::qtractorPluginParamCommand (
qtractorPluginParam *pParam, float fValue, bool bUpdate )
: qtractorCommand(QString(pParam->name()).toLower()),
m_pParam(pParam), m_fValue(fValue), m_bUpdate(bUpdate),
m_fPrevValue(pParam->value())
{
setRefresh(false);
// Try replacing an previously equivalent command...
static qtractorPluginParamCommand *s_pPrevParamCommand = NULL;
if (s_pPrevParamCommand) {
qtractorSession *pSession = qtractorSession::getInstance();
qtractorCommand *pLastCommand
= (pSession->commands())->lastCommand();
qtractorCommand *pPrevCommand
= static_cast<qtractorCommand *> (s_pPrevParamCommand);
if (pPrevCommand == pLastCommand
&& s_pPrevParamCommand->param() == pParam) {
qtractorPluginParamCommand *pLastParamCommand
= static_cast<qtractorPluginParamCommand *> (pLastCommand);
if (pLastParamCommand) {
// Equivalence means same (sign) direction too...
const float fPrevValue = pLastParamCommand->prevValue();
const float fLastValue = pLastParamCommand->value();
const int iPrevSign = (fPrevValue > fLastValue ? +1 : -1);
const int iCurrSign = (fPrevValue < m_fValue ? +1 : -1);
if (iPrevSign == iCurrSign || m_fValue == m_fPrevValue) {
m_fPrevValue = fLastValue;
(pSession->commands())->removeLastCommand();
}
}
}
}
s_pPrevParamCommand = this;
}
CCopasiTimer::CCopasiTimer(const Type & type,
const CCopasiContainer * pParent):
CCopasiObject((type == CCopasiTimer::WALL) ? "Wall Clock Time" : "CPU Time",
pParent, "Timer", CCopasiObject::ValueDbl),
mType(type),
mStartTime(),
mElapsedTime(0),
mElapsedTimeSeconds(0)
{
switch (mType)
{
case WALL:
mStartTime = CCopasiTimeVariable::getCurrentWallTime();
break;
case PROCESS:
mStartTime = CCopasiTimeVariable::getProcessTime();
break;
case THREAD:
mStartTime = CCopasiTimeVariable::getThreadTime();
break;
}
setRefresh(this, &CCopasiTimer::refresh);
}
// Constructor.
qtractorTrackMonitorCommand::qtractorTrackMonitorCommand (
qtractorTrack *pTrack, bool bMonitor, bool bMidiControl )
: qtractorTrackControlCommand(
QObject::tr("track monitor"), pTrack, bMidiControl)
{
m_bMonitor = bMonitor;
// Toggle/update all other?
qtractorMainForm *pMainForm = qtractorMainForm::getInstance();
if (pMainForm) {
qtractorTracks *pTracks = pMainForm->tracks();
if (pTracks) {
const Qt::KeyboardModifiers& modifiers
= QApplication::keyboardModifiers();
const bool bAllTracks
= (modifiers & (Qt::ShiftModifier | Qt::ControlModifier));
if (modifiers & Qt::ControlModifier)
bMonitor = !bMonitor;
const QList<qtractorTrack *>& tracks
= pTracks->trackList()->selectedTracks(track(), bAllTracks);
QListIterator<qtractorTrack *> iter(tracks);
while (iter.hasNext())
m_tracks.append(new TrackItem(iter.next(), bMonitor));
}
}
setRefresh(false);
}
void ServoClass::writeMicroseconds(uint8_t index, unsigned long value)
{
if ((MIN_SERVO_PULSE_WIDTH <= value) && (value <= MAX_SERVO_PULSE_WIDTH) && (index < SERVOS_PER_TIMER))
g_ulServoPulse[index] = value;
setRefresh();
}
// Constructor.
qtractorPluginCommand::qtractorPluginCommand ( const QString& sName,
qtractorPlugin *pPlugin ) : qtractorCommand(sName)
{
if (pPlugin)
m_plugins.append(pPlugin);
setRefresh(false);
}
CCopasiTimer::CCopasiTimer(const CCopasiTimer & src,
const CCopasiContainer * pParent):
CCopasiObject(src, pParent),
mType(src.mType),
mStartTime(src.mStartTime),
mElapsedTime(src.mElapsedTime),
mElapsedTimeSeconds(src.mElapsedTimeSeconds)
{setRefresh(this, &CCopasiTimer::refresh);}
// Constructor.
qtractorPluginPropertyCommand::qtractorPluginPropertyCommand (
qtractorPlugin *pPlugin, unsigned long iProperty, const QVariant& value )
: qtractorPluginCommand(QObject::tr("plugin property"), pPlugin)
{
m_iProperty = iProperty;
m_value = value;
setRefresh(false);
}
void ServoClass::detach(uint8_t index)
{
if (index < SERVOS_PER_TIMER)
{
digitalWrite(g_ulServoPins[index], LOW);
g_ulServoPins[index] = INVALID_SERVO_PIN;
g_ulServoPulse[index] = DEFAULT_SERVO_PULSE_WIDTH;
setRefresh();
}
}
ServoClass::ServoClass()
{
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
SYSCTL_OSC_MAIN);
// Initialize variables of the class
g_ulPeriod = 0;
for(int il_iter = 0; il_iter < SERVOS_PER_TIMER; il_iter++)
{
g_ulServoPins[il_iter] = INVALID_SERVO_PIN;
g_ulServoPulse[il_iter] = DEFAULT_SERVO_PULSE_WIDTH;
}
g_iServoNo = 0;
g_ulPulseWidth = 0;
g_ulTicksPerMicrosecond = 0;
setRefresh();
// for(int il_iter = 0; il_iter < SERVOS_PER_TIMER; il_iter++)
// {
// if (g_ulServoPins[il_iter] != INVALID_SERVO_PIN)
// {
// pinMode(g_ulServoPins[il_iter], OUTPUT);
// digitalWrite(g_ulServoPins[il_iter], LOW);
// }
// }
// Enable TIMER
ROM_SysCtlPeripheralEnable(SERVO_TIMER_PERIPH);
// Enable processor interrupts.
ROM_IntMasterEnable();
// Configure the TIMER
ROM_TimerConfigure(SERVO_TIMER, SERVO_TIME_CFG);
// Calculate the number of timer counts/microsecond
g_ulTicksPerMicrosecond = ROM_SysCtlClockGet() / 1000000;
g_ulPeriod = g_ulTicksPerMicrosecond * REFRESH_INTERVAL; // 20ms = Standard Servo refresh delay
// Initially load the timer with 20ms interval time
ROM_TimerLoadSet(SERVO_TIMER, SERVO_TIMER_A, g_ulPeriod);
// Setup the interrupt for the TIMER1A timeout.
ROM_IntEnable(SERVO_TIMER_INTERRUPT);
ROM_TimerIntEnable(SERVO_TIMER, SERVO_TIMER_TRIGGER);
// Enable the timer.
ROM_TimerEnable(SERVO_TIMER, SERVO_TIMER_A);
}
// Constructor.
qtractorTrackStateCommand::qtractorTrackStateCommand ( qtractorTrack *pTrack,
qtractorTrack::ToolType toolType, bool bOn, bool bMidiControl )
: qtractorTrackControlCommand(QString(), pTrack, bMidiControl)
{
m_toolType = toolType;
m_bOn = bOn;
m_pClipCommand = NULL;
m_iRecordCount = 0;
switch (m_toolType) {
case qtractorTrack::Record:
qtractorTrackCommand::setName(QObject::tr("track record"));
break;
case qtractorTrack::Mute:
qtractorTrackCommand::setName(QObject::tr("track mute"));
break;
case qtractorTrack::Solo:
qtractorTrackCommand::setName(QObject::tr("track solo"));
break;
}
// Toggle/update all other?
if (m_toolType != qtractorTrack::Record) {
qtractorMainForm *pMainForm = qtractorMainForm::getInstance();
if (pMainForm) {
qtractorTracks *pTracks = pMainForm->tracks();
if (pTracks) {
const Qt::KeyboardModifiers& modifiers
= QApplication::keyboardModifiers();
const bool bAllTracks
= (modifiers & (Qt::ShiftModifier | Qt::ControlModifier));
if (modifiers & Qt::ControlModifier)
bOn = !bOn;
const QList<qtractorTrack *>& tracks
= pTracks->trackList()->selectedTracks(track(), bAllTracks);
QListIterator<qtractorTrack *> iter(tracks);
while (iter.hasNext())
m_tracks.append(new TrackItem(iter.next(), bOn));
}
}
}
setRefresh(m_toolType != qtractorTrack::Record);
}
void CMoiety::initObjects()
{
setRefresh(this, &CMoiety::refreshDependentNumber);
mpINumberReference = new CTotalNumberReference("InitialValue", this, mINumber);
mpINumberReference->setRefresh(this, &CMoiety::refreshInitialValue);
mpNumberReference = new CTotalNumberReference("Value", this, mNumber);
mpNumberReference->setRefresh(this, &CMoiety::refreshValue);
mpDNumberReference = new CDependentNumberReference("DependentValue", this, mNumber);
mpDNumberReference->addDirectDependency(this);
CCopasiObject * pObject = addObjectReference("Amount", mIAmount, CCopasiObject::ValueDbl);
pObject->setRefresh(this, &CMoiety::refreshAmount);
pObject->addDirectDependency(mpNumberReference);
return;
}
void Drawing::eventHandler() {
//Event handler
SDL_Event e;
//While application is running
while( Quit == false)
{
//Handle events on queue
//update surface
if(refresh) {
SDL_UpdateWindowSurface( getWindowPointer());//Window );
// similarly event driven
refresh = false;
}
while( SDL_PollEvent( &e ) != 0 )
{
//User requests quit
if( e.type == SDL_QUIT )
{
Quit = true;
//break;
}
else if( e.type == SDL_KEYDOWN) {
// for test
if(e.key.keysym.sym == SDLK_a) {
cout << "A" << endl;
for(int i = 0; i < ScreenHeight/10; i++) {
for(int j = 0; j < ScreenWidth/10; j++) {
//cout << getPixel(i*10, j*10) << ' ';
setPixel(i*10, j*10, (0xff << 16));
}
}
setRefresh(true);
restart = true;
}
}
}
}
}
// Constructor.
qtractorBusCommand::qtractorBusCommand ( const QString& sName,
qtractorBus *pBus, qtractorBus::BusMode busMode )
: qtractorCommand(sName), m_pBus(pBus), m_busMode(busMode),
m_busType(qtractorTrack::None), m_bMonitor(false),
m_iChannels(0), m_bAutoConnect(false)
{
setRefresh(false);
// Set initial bus properties if any...
if (m_pBus && m_busMode == qtractorBus::None) {
m_busMode = m_pBus->busMode();
m_busType = m_pBus->busType();
m_sBusName = m_pBus->busName();
m_bMonitor = m_pBus->isMonitor();
// Special case typed buses...
switch (m_pBus->busType()) {
case qtractorTrack::Audio: {
qtractorAudioBus *pAudioBus
= static_cast<qtractorAudioBus *> (m_pBus);
if (pAudioBus) {
m_iChannels = pAudioBus->channels();
m_bAutoConnect = pAudioBus->isAutoConnect();
}
break;
}
case qtractorTrack::Midi: {
qtractorMidiBus *pMidiBus
= static_cast<qtractorMidiBus *> (m_pBus);
if (pMidiBus) {
m_sInstrumentName = pMidiBus->instrumentName();
}
break;
}
case qtractorTrack::None:
default:
break;
}
}
}
// Constructor.
qtractorTrackPanningCommand::qtractorTrackPanningCommand (
qtractorTrack *pTrack, float fPanning, bool bMidiControl )
: qtractorTrackControlCommand(
QObject::tr("track pan"), pTrack, bMidiControl)
{
m_fPanning = fPanning;
m_fPrevPanning = pTrack->prevPanning();
setRefresh(false);
// Try replacing an previously equivalent command...
static qtractorTrackPanningCommand *s_pPrevPanningCommand = NULL;
if (s_pPrevPanningCommand) {
qtractorSession *pSession = qtractorSession::getInstance();
qtractorCommand *pLastCommand
= (pSession->commands())->lastCommand();
qtractorCommand *pPrevCommand
= static_cast<qtractorCommand *> (s_pPrevPanningCommand);
if (pPrevCommand == pLastCommand
&& s_pPrevPanningCommand->track() == pTrack) {
qtractorTrackPanningCommand *pLastPanningCommand
= static_cast<qtractorTrackPanningCommand *> (pLastCommand);
if (pLastPanningCommand) {
// Equivalence means same (sign) direction too...
const float fPrevPanning = pLastPanningCommand->prevPanning();
const float fLastPanning = pLastPanningCommand->panning();
const int iPrevSign = (fPrevPanning > fLastPanning ? +1 : -1);
const int iCurrSign = (fPrevPanning < m_fPanning ? +1 : -1);
if (iPrevSign == iCurrSign || m_fPanning == m_fPrevPanning) {
m_fPrevPanning = fLastPanning;
(pSession->commands())->removeLastCommand();
}
}
}
}
s_pPrevPanningCommand = this;
}
// Constructor.
qtractorPluginParamValuesCommand::qtractorPluginParamValuesCommand (
const QString& sName ) : qtractorCommand(sName)
{
setRefresh(false);
}
// Track-button command method.
bool qtractorTrackStateCommand::redo (void)
{
qtractorTrack *pTrack = track();
if (pTrack == NULL)
return false;
qtractorSession *pSession = pTrack->session();
if (pSession == NULL)
return false;
qtractorMainForm *pMainForm = qtractorMainForm::getInstance();
if (pMainForm == NULL)
return false;
bool bOn = false;
qtractorMmcEvent::SubCommand scmd = qtractorMmcEvent::TRACK_NONE;
qtractorMidiControl::Command ccmd = qtractorMidiControl::Command(0);
switch (m_toolType) {
case qtractorTrack::Record:
scmd = qtractorMmcEvent::TRACK_RECORD;
ccmd = qtractorMidiControl::TRACK_RECORD;
// Special stuffing if currently recording at first place...
bOn = pTrack->isRecord();
if (bOn && !m_bOn
&& m_pClipCommand == NULL && m_iRecordCount == 0) {
m_pClipCommand = new qtractorClipCommand(QString());
// Do all the record stuffing here...
const unsigned long iFrameTime = pSession->frameTimeEx();
if (m_pClipCommand->addClipRecord(pTrack, iFrameTime)) {
// Yes, we've recorded something...
setRefresh(true);
} else {
// nothing was actually recorded...
delete m_pClipCommand;
m_pClipCommand = NULL;
}
}
// Was it before (skip undos)?
if (m_pClipCommand && (m_iRecordCount % 2) == 0)
m_pClipCommand->redo();
++m_iRecordCount;
// Carry on...
pTrack->setRecord(m_bOn);
break;
case qtractorTrack::Mute:
scmd = qtractorMmcEvent::TRACK_MUTE;
ccmd = qtractorMidiControl::TRACK_MUTE;
bOn = pTrack->isMute();
pTrack->setMute(m_bOn);
break;
case qtractorTrack::Solo:
scmd = qtractorMmcEvent::TRACK_SOLO;
ccmd = qtractorMidiControl::TRACK_SOLO;
bOn = pTrack->isSolo();
pTrack->setSolo(m_bOn);
break;
default:
// Whaa?
return false;
}
// Send MMC MASKED_WRITE command...
qtractorMidiEngine *pMidiEngine = pSession->midiEngine();
int iTrack = pSession->tracks().find(pTrack);
if (pMidiEngine)
pMidiEngine->sendMmcMaskedWrite(scmd, iTrack, m_bOn);
// Send MIDI controller command...
if (midiControlFeedback()) {
qtractorMidiControl *pMidiControl = qtractorMidiControl::getInstance();
if (pMidiControl)
pMidiControl->processTrackCommand(ccmd, iTrack, m_bOn);
}
// Update track list item...
qtractorTrackList *pTrackList = pMainForm->tracks()->trackList();
pTrackList->updateTrack(pTrack);
// Reset for undo.
m_bOn = bOn;
// Toggle/update all other?
if (!m_tracks.isEmpty()) {
// Exclusive mode.
qtractorMidiControl *pMidiControl = qtractorMidiControl::getInstance();
QListIterator<TrackItem *> iter(m_tracks);
while (iter.hasNext()) {
TrackItem *pTrackItem = iter.next();
pTrack = pTrackItem->track;
bOn = false;
if (m_toolType == qtractorTrack::Mute) {
bOn = pTrack->isMute();
pTrack->setMute(pTrackItem->on);
}
else
if (m_toolType == qtractorTrack::Solo) {
bOn = pTrack->isSolo();
pTrack->setSolo(pTrackItem->on);
}
// Send MMC MASKED_WRITE command...
iTrack = pTrackList->trackRow(pTrack);
if (pMidiEngine)
pMidiEngine->sendMmcMaskedWrite(scmd, iTrack, pTrackItem->on);
// Send MIDI controller command...
if (pMidiControl)
pMidiControl->processTrackCommand(ccmd, iTrack, pTrackItem->on);
// Update track list item...
pTrackList->updateTrack(pTrack);
// Swap for undo...
pTrackItem->on = bOn;
}
// Done with exclusive mode.
}
return true;
}
