TEST_F(TModbusDeviceTest, OnValue)
{
FilterConfig("OnValueTest");
PModbusSlave slave = ModbusServer->SetSlave(
Config->PortConfigs[0]->DeviceConfigs[0]->SlaveId,
TModbusRange(
TServerRegisterRange(),
TServerRegisterRange(),
TServerRegisterRange(0, 1),
TServerRegisterRange()));
ModbusServer->Start();
PMQTTSerialObserver observer(new TMQTTSerialObserver(MQTTClient, Config));
observer->SetUp();
slave->Holding[0] = 0;
Note() << "LoopOnce()";
observer->LoopOnce();
MQTTClient->DoPublish(true, 0, "/devices/OnValueTest/controls/Relay 1/on", "1");
Note() << "LoopOnce()";
observer->LoopOnce();
ASSERT_EQ(500, slave->Holding[0]);
slave->Holding[0] = 0;
Note() << "LoopOnce() after slave update";
observer->LoopOnce();
slave->Holding[0] = 500;
Note() << "LoopOnce() after second slave update";
observer->LoopOnce();
}
TEST_F(TModbusClientTest, Poll)
{
PRegister coil0 = RegCoil(0);
PRegister coil1 = RegCoil(1);
PRegister discrete10 = RegDiscrete(10);
PRegister holding22 = RegHolding(22);
PRegister input33 = RegInput(33);
SerialClient->AddRegister(coil0);
SerialClient->AddRegister(coil1);
SerialClient->AddRegister(discrete10);
SerialClient->AddRegister(holding22);
SerialClient->AddRegister(input33);
Note() << "Cycle()";
SerialClient->Cycle();
Slave->Coils[1] = 1;
Slave->Discrete[10] = 1;
Slave->Holding[22] = 4242;
Slave->Input[33] = 42000;
FakeSerial->Flush();
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ(to_string(0), SerialClient->GetTextValue(coil0));
EXPECT_EQ(to_string(1), SerialClient->GetTextValue(coil1));
EXPECT_EQ(to_string(1), SerialClient->GetTextValue(discrete10));
EXPECT_EQ(to_string(4242), SerialClient->GetTextValue(holding22));
EXPECT_EQ(to_string(42000), SerialClient->GetTextValue(input33));
}
void LeitnerNoteGenerator::generateBucket()
{
if (mSessionCurrentNumber != 0 && mSessionCurrentNumber % 2 == 0)
{
mWorkingBucket.clear();
mSuccessBucket.clear();
mSuccesSpeed -= 100;
std::cout << "New Speed:" << mSuccesSpeed << "\n";
}
for (int i = 0; i < mSessionSize; ++i)
{
int proposedNoteNumber = -1;
while (proposedNoteNumber == -1)
{
proposedNoteNumber = (rand() % 12) + mMinNote.getNumber() + 12*(mSessionCurrentNumber%2);
if (mChooseOnlyPlainNotes)
if (Note::isSharpOrFlat(proposedNoteNumber))
proposedNoteNumber = -1;
if (std::find(mWorkingBucket.begin(), mWorkingBucket.end(), Note(proposedNoteNumber)) != mWorkingBucket.end())
{
proposedNoteNumber = -1;
}
}
mWorkingBucket.push_back(Note(proposedNoteNumber));
}
mSessionCurrentNumber += 1;
mNoteHasBeenAnswered = true;
printBucketState();
}
void TModbusDeviceTest::VerifyDDL24()
{
PModbusSlave slave = ModbusServer->SetSlave(
Config->PortConfigs[0]->DeviceConfigs[0]->SlaveId,
TModbusRange(
TServerRegisterRange(),
TServerRegisterRange(),
TServerRegisterRange(4, 19),
TServerRegisterRange()));
ModbusServer->Start();
PMQTTSerialObserver observer(new TMQTTSerialObserver(MQTTClient, Config));
observer->SetUp();
Note() << "LoopOnce()";
observer->LoopOnce();
MQTTClient->DoPublish(true, 0, "/devices/ddl24/controls/RGB/on", "10;20;30");
FakeSerial->Flush();
Note() << "LoopOnce()";
observer->LoopOnce();
ASSERT_EQ(10, slave->Holding[4]);
ASSERT_EQ(20, slave->Holding[5]);
ASSERT_EQ(30, slave->Holding[6]);
FakeSerial->Flush();
slave->Holding[4] = 32;
slave->Holding[5] = 64;
slave->Holding[6] = 128;
Note() << "LoopOnce() after slave update";
observer->LoopOnce();
}
void
TempoDialog::updateBeatLabels(double qpm)
{
Composition &comp = m_doc->getComposition();
// If the time signature's beat is not a crotchet, need to show
// bpm separately
timeT beat = comp.getTimeSignatureAt(m_tempoTime).getBeatDuration();
if (beat == Note(Note::Crotchet).getDuration()) {
m_tempoBeatLabel->setText(tr(" bpm"));
m_tempoBeatLabel->show();
m_tempoBeat->hide();
m_tempoBeatsPerMinute->hide();
} else {
m_tempoBeatLabel->setText(" ");
timeT error = 0;
m_tempoBeat->setPixmap(NotePixmapFactory::makeNoteMenuPixmap(beat, error));
m_tempoBeat->setMaximumWidth(25);
if (error) {
m_tempoBeat->setPixmap
(NotePixmapFactory::makeToolbarPixmap("menu-no-note"));
}
m_tempoBeatsPerMinute->setText
(QString("= %1 ").arg
(int(qpm * Note(Note::Crotchet).getDuration() / beat)));
m_tempoBeatLabel->show();
m_tempoBeat->show();
m_tempoBeatsPerMinute->show();
}
}
TEST_F(TModbusClientTest, Float32)
{
// create scaled register
PRegister holding24 = RegHolding(24, Float, 100);
SerialClient->AddRegister(holding24);
PRegister holding20 = RegHolding(20, Float);
PRegister input30 = RegInput(30, Float);
SerialClient->AddRegister(holding20);
SerialClient->AddRegister(input30);
Note() << "server -> client: 0x45d2 0x0000, 0x449d 0x8000";
Slave->Holding[20] = 0x45d2;
Slave->Holding[21] = 0x0000;
Slave->Input[30] = 0x449d;
Slave->Input[31] = 0x8000;
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ("6720", SerialClient->GetTextValue(holding20));
EXPECT_EQ("1260", SerialClient->GetTextValue(input30));
FakeSerial->Flush();
Note() << "client -> server: 10";
SerialClient->SetTextValue(holding20, "10");
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ("10", SerialClient->GetTextValue(holding20));
EXPECT_EQ(0x4120, Slave->Holding[20]);
EXPECT_EQ(0x0000, Slave->Holding[21]);
FakeSerial->Flush();
Note() << "client -> server: -0.00123";
SerialClient->SetTextValue(holding20, "-0.00123");
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ("-0.00123", SerialClient->GetTextValue(holding20));
EXPECT_EQ(0xbaa1, Slave->Holding[20]);
EXPECT_EQ(0x37f4, Slave->Holding[21]);
FakeSerial->Flush();
Note() << "client -> server: -0.123 (scaled)";
SerialClient->SetTextValue(holding24, "-0.123");
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ("-0.123", SerialClient->GetTextValue(holding24));
EXPECT_EQ(0xbaa1, Slave->Holding[24]);
EXPECT_EQ(0x37f4, Slave->Holding[25]);
FakeSerial->Flush();
Note() << "server -> client: 0x449d 0x8000 (scaled)";
Slave->Holding[24] = 0x449d;
Slave->Holding[25] = 0x8000;
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ("126000", SerialClient->GetTextValue(holding24));
}
ChordPlayer::ChordPlayer(rt::Pitch::Pitch rtKy, rt::Channel::Channel chnnl, rt::Channel::Channel ntOnChnnl)
: rootKey(rtKy)
, Player(chnnl)
, NoteOnCallback(ntOnChnnl)
{
pitches.push_back(Note(rtKy,100));
pitches.push_back(Note(rtKy+4,100));
pitches.push_back(Note(rtKy+7,100));
pitches.push_back(Note(rtKy+12,100));
}
int MySQL::Update(PSList* _list){
assert(NULL != _list);
try{
Note("=================>Size:%d<================", _list->size());
if(conn_->isClosed()){
Connect();
}
conn_->setAutoCommit(0);
int index = 0;
PSList::iterator it = _list->begin();
for(; it != _list->end(); it++, index++){
(*it)->executeUpdate();
Note("================> %d <=================", index);
}
conn_->commit();
}
catch(sql::SQLException &e){
conn_->rollback();
Error("MySQL exception: func=%s, line=%d, expno=%d, sqlstate=%s, expstr=%s",
__func__, __LINE__, e.getErrorCode(), e.getSQLState().c_str(), e.what());
return -1;
}
catch (std::runtime_error &e) {
conn_->rollback();
Error("Update runtime error: errstr=%s", e.what());
return -1;
}
return 1;
} //Update PSList
TEST_F(TModbusClientTest, S32)
{
PRegister holding20 = RegHolding(20, S32);
PRegister input30 = RegInput(30, S32);
SerialClient->AddRegister(holding20);
SerialClient->AddRegister(input30);
// create scaled register
PRegister holding24 = RegHolding(24, S32, 0.001);
SerialClient->AddRegister(holding24);
Note() << "server -> client: 10, 20";
Slave->Holding[20] = 0x00AA;
Slave->Holding[21] = 0x00BB;
Slave->Input[30] = 0xFFFF;
Slave->Input[31] = 0xFFFF;
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ(to_string(0x00AA00BB), SerialClient->GetTextValue(holding20));
EXPECT_EQ(to_string(-1), SerialClient->GetTextValue(input30));
FakeSerial->Flush();
Note() << "client -> server: 10";
SerialClient->SetTextValue(holding20, "10");
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ(to_string(10), SerialClient->GetTextValue(holding20));
EXPECT_EQ(0, Slave->Holding[20]);
EXPECT_EQ(10, Slave->Holding[21]);
FakeSerial->Flush();
Note() << "client -> server: -2";
SerialClient->SetTextValue(holding20, "-2");
EXPECT_EQ(to_string(-2), SerialClient->GetTextValue(holding20));
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ(to_string(-2), SerialClient->GetTextValue(holding20));
EXPECT_EQ(0xFFFF, Slave->Holding[20]);
EXPECT_EQ(0xFFFE, Slave->Holding[21]);
Note() << "client -> server: -0.123 (scaled)";
SerialClient->SetTextValue(holding24, "-0.123");
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ("-0.123", SerialClient->GetTextValue(holding24));
EXPECT_EQ(0xffff, Slave->Holding[24]);
EXPECT_EQ(0xff85, Slave->Holding[25]);
Note() << "server -> client: 0xffff 0xff85 (scaled)";
Slave->Holding[24] = 0xffff;
Slave->Holding[25] = 0xff85;
Note() << "Cycle()";
SerialClient->Cycle();
EXPECT_EQ("-0.123", SerialClient->GetTextValue(holding24));
}
int SegmentPencil::mouseMoveEvent(QMouseEvent *e)
{
// No need to propagate.
e->accept();
QPoint pos = m_canvas->viewportToContents(e->pos());
if (!m_newRect) {
setContextHelpFor(pos);
return RosegardenScrollView::NoFollow;
}
// If shift isn't being held down
if ((e->modifiers() & Qt::ShiftModifier) == 0) {
setContextHelp(tr("Hold Shift to avoid snapping to bar lines"));
} else {
clearContextHelp();
}
QRect tmpRect = m_canvas->getNewSegmentRect();
SnapGrid &snapGrid = m_canvas->grid();
setSnapTime(e, SnapGrid::SnapToBar);
int mouseX = pos.x();
// if mouse X is to the right of the original Press point
if (mouseX >= m_pressX) {
m_startTime = snapGrid.snapX(m_pressX, SnapGrid::SnapLeft);
m_endTime = snapGrid.snapX(mouseX, SnapGrid::SnapRight);
// Make sure the segment is never smaller than the smallest note.
if (m_endTime - m_startTime < Note(Note::Shortest).getDuration())
m_endTime = m_startTime + Note(Note::Shortest).getDuration();
} else { // we are to the left of the original Press point
m_startTime = snapGrid.snapX(mouseX, SnapGrid::SnapLeft);
m_endTime = snapGrid.snapX(m_pressX, SnapGrid::SnapRight);
// Make sure the segment is never smaller than the smallest note.
if (m_endTime - m_startTime < Note(Note::Shortest).getDuration())
m_startTime = m_endTime - Note(Note::Shortest).getDuration();
}
int leftX = snapGrid.getRulerScale()->getXForTime(m_startTime);
int rightX = snapGrid.getRulerScale()->getXForTime(m_endTime);
// Adjust the rectangle to go from leftX to rightX
tmpRect.setLeft(leftX);
tmpRect.setRight(rightX);
m_canvas->drawNewSegment(tmpRect);
return RosegardenScrollView::FollowHorizontal;
}
void ribi::Music::Note::Test() noexcept
{
//Test exactly once
{
static bool is_tested{false};
if (is_tested) return;
is_tested = true;
}
//Test ToInt
{
assert(Note(Letter::C).ToInt() == 0);
assert(Note(0).ToInt() == 0);
assert(Note(0).ToStr() == "C");
}
}
/*
@protected
*/
int ClientImpl::init() {
server_ = NULL;
switch(Load()) {
case -1:
Error("ClientImpl init failed");
return -1;
case 0:
server_ = new Client(timeout_, tcpaddr_);
Note("New Client: addr=%p", server_);
if(NULL == server_) {
Error("New Client failed");
return -1;
}
break;
}
return 1;
}
void QExercise::startCheckAnswer()
{
mState = CheckAnswer;
mAnswerTimeInMs = mTime.elapsed();
mPresenter->setNoteNameVisible(true);
std::string evalMessage = "";
if ( mIgnoreOctaveNumberInAnswer )
{
mNoteAnswered = Note(mNoteToFind.getOctaveNumber(), mNoteAnswered.getIndexInOctave() );
}
bool success = mNoteGenerator->evaluateAnswer(mNoteAnswered, mAnswerTimeInMs, evalMessage);
mPresenter->setText( evalMessage.c_str() );
mNoteCount++;
//mPresenter->getStaff()->setNote( Note() );
QString dateTime = QDateTime::currentDateTime().toString();
QByteArray dateTimeData = dateTime.toUtf8();
mLog << dateTimeData.constData() << ";";
mLog << mNoteCount << ";";
mLog << mNoteToFind.getNumber() << ";";
mLog << mNoteToFind.getName(true) << ";";
mLog << mNoteAnswered.getNumber() << ";";
mLog << mNoteAnswered.getName(true) << ";";
mLog << mAnswerTimeInMs << ";";
mLog << success << ";";
mLog << std::endl;
nextState();
}
void Track_Pattern::reset_last_notes() {
for(int i=0;i<MAX_COLUMNS;i++) {
data.last_note[i]=Note(Note::NOTE_OFF);
}
}
void
EditViewBase::slotSetSegmentDuration()
{
Segment *s = getCurrentSegment();
if (!s)
return ;
TimeDialog dialog(this, tr("Segment Duration"),
&getDocument()->getComposition(),
s->getStartTime(),
s->getEndMarkerTime() - s->getStartTime(),
Note(Note::Shortest).getDuration(), false);
if (dialog.exec() == QDialog::Accepted) {
SegmentReconfigureCommand *command =
new SegmentReconfigureCommand(tr("Set Segment Duration"),
&getDocument()->getComposition());
command->addSegment
(s, s->getStartTime(),
s->getStartTime() + dialog.getTime(),
s->getTrack());
CommandHistory::getInstance()->addCommand(command);
}
}
Track_Pattern::Note Track_Pattern::get_note(const Position& p_pos) {
int pb_idx = get_block_idx_at_pos( p_pos.tick );
ERR_FAIL_COND_V(pb_idx==-1,Note());
PatternBlock *bp=get_block(pb_idx);
ERR_FAIL_COND_V(bp==NULL,Note());
Position rel_pos( p_pos.tick-get_block_pos(pb_idx) , p_pos.column );
int tick_idx = bp->get_pattern()->data.get_exact_index(rel_pos);
if (tick_idx==INVALID_STREAM_INDEX)
return Note(); //return empty note, as pos in tick does not exist */
return bp->get_pattern()->data.get_index_value(tick_idx);
}
void Analyzer::addNote(char ch)
{
if(vowels.find(ch)!=string::npos)
{
notes.push_back(Note(getRandomDuration(),false));
}
}
void FCompilerResultsLog::InternalLogEvent(const FCompilerEvent& InEvent, int32 InDepth)
{
const int EventTimeMs = (int)((InEvent.FinishTime - InEvent.StartTime) * 1000);
if(EventTimeMs >= EventDisplayThresholdMs)
{
// Skip display of the top-most event since that time has already been logged
if(InDepth > 0)
{
FString EventString = FString::Printf(TEXT("- %s"), *InEvent.Name);
if(InEvent.Counter > 0)
{
EventString.Append(FString::Printf(TEXT(" (%d)"), InEvent.Counter + 1));
}
FFormatNamedArguments Args;
Args.Add(TEXT("EventTimeMs"), EventTimeMs);
EventString.Append(FText::Format(LOCTEXT("PerformanceSummaryEventTime", " [{EventTimeMs} ms]"), Args).ToString());
FString IndentString = FString::Printf(TEXT("%*s"), (InDepth - 1) << 1, TEXT(""));
Note(*FString::Printf(TEXT("%s%s"), *IndentString, *EventString));
}
const int32 NumChildEvents = InEvent.ChildEvents.Num();
for(int32 i = 0; i < NumChildEvents; ++i)
{
InternalLogEvent(InEvent.ChildEvents[i].Get(), InDepth + 1);
}
}
}
void Analyzer::checkBar(char ch)
{
if (ch==' ')
{
bars++;
notes.push_back(Note(getRandomDuration(), true));
}
}
TEST_F(TModbusDeviceTest, Errors)
{
FilterConfig("DDL24");
PModbusSlave slave = ModbusServer->SetSlave(
Config->PortConfigs[0]->DeviceConfigs[0]->SlaveId,
TModbusRange(
TServerRegisterRange(),
TServerRegisterRange(),
TServerRegisterRange(4, 19),
TServerRegisterRange()));
ModbusServer->Start();
PMQTTSerialObserver observer(new TMQTTSerialObserver(MQTTClient, Config));
observer->SetUp();
slave->Holding.BlacklistRead(4, true);
slave->Holding.BlacklistWrite(4, true);
slave->Holding.BlacklistRead(7, true);
slave->Holding.BlacklistWrite(7, true);
Note() << "LoopOnce() [read, rw blacklisted]";
observer->LoopOnce();
MQTTClient->DoPublish(true, 0, "/devices/ddl24/controls/RGB/on", "10;20;30");
MQTTClient->DoPublish(true, 0, "/devices/ddl24/controls/White/on", "42");
Note() << "LoopOnce() [write, rw blacklisted]";
observer->LoopOnce();
slave->Holding.BlacklistRead(4, false);
slave->Holding.BlacklistWrite(4, false);
slave->Holding.BlacklistRead(7, false);
slave->Holding.BlacklistWrite(7, false);
Note() << "LoopOnce() [read, nothing blacklisted]";
observer->LoopOnce();
MQTTClient->DoPublish(true, 0, "/devices/ddl24/controls/RGB/on", "10;20;30");
MQTTClient->DoPublish(true, 0, "/devices/ddl24/controls/White/on", "42");
Note() << "LoopOnce() [write, nothing blacklisted]";
observer->LoopOnce();
Note() << "LoopOnce() [read, nothing blacklisted] (2)";
observer->LoopOnce();
}
NoteContainer
Swing8::get_notes()
{
NoteContainer n;
counter++;
n.add_note(Note((char *)"C", 4));
return n;
}
void FCompilerResultsLog::InternalLogSummary()
{
if(CurrentEventScope.IsValid())
{
const double CompileStartTime = CurrentEventScope->StartTime;
const double CompileFinishTime = CurrentEventScope->FinishTime;
FNumberFormattingOptions TimeFormat;
TimeFormat.MaximumFractionalDigits = 2;
TimeFormat.MinimumFractionalDigits = 2;
TimeFormat.MaximumIntegralDigits = 4;
TimeFormat.MinimumIntegralDigits = 4;
TimeFormat.UseGrouping = false;
FFormatNamedArguments Args;
Args.Add(TEXT("Time"), FText::AsNumber(CompileFinishTime - GStartTime, &TimeFormat));
Args.Add(TEXT("SourceName"), FText::FromString(FPackageName::ObjectPathToObjectName(SourcePath)));
Args.Add(TEXT("SourcePath"), FText::FromString(SourcePath));
Args.Add(TEXT("NumWarnings"), NumWarnings);
Args.Add(TEXT("NumErrors"), NumErrors);
Args.Add(TEXT("TotalMilliseconds"), (int)((CompileFinishTime - CompileStartTime) * 1000));
if (NumErrors > 0)
{
FString FailMsg = FText::Format(LOCTEXT("CompileFailed", "[{Time}] Compile of {SourceName} failed. {NumErrors} Fatal Issue(s) {NumWarnings} Warning(s) [in {TotalMilliseconds} ms] ({SourcePath})"), Args).ToString();
Warning(*FailMsg);
}
else if(NumWarnings > 0)
{
FString WarningMsg = FText::Format(LOCTEXT("CompileWarning", "[{Time}] Compile of {SourceName} successful, but with {NumWarnings} Warning(s) [in {TotalMilliseconds} ms] ({SourcePath})"), Args).ToString();
Warning(*WarningMsg);
}
else
{
FString SuccessMsg = FText::Format(LOCTEXT("CompileSuccess", "[{Time}] Compile of {SourceName} successful! [in {TotalMilliseconds} ms] ({SourcePath})"), Args).ToString();
Note(*SuccessMsg);
}
if(bLogDetailedResults)
{
Note(*LOCTEXT("PerformanceSummaryHeading", "Performance summary:").ToString());
InternalLogEvent(*CurrentEventScope.Get());
}
}
}
NoteContainer
RockDrum::get_notes()
{
NoteContainer n;
if (RANDOM() <= 0.1)
n.add_note(Note((char *)"A#", 2));
else if (RANDOM() <= 0.1)
n.add_note(Note((char *)"A#", 2));
if (counter == 1){
n.add_note(Note((char *)"C", 2));
n.add_note(Note((char *)"C#", 3));
}
else if (counter == 5)
n.add_note(Note((char *)"E", 2));
else if (counter >= 7)
{
if (RANDOM() <= 0.2)
n.add_note(Note((char *)"B", 2));
else if (RANDOM() <= 0.2)
n.add_note(Note((char *)"A", 2));
}
counter++;
if (counter > 8)
counter = 1;
return n;
}
int main(){
NoteSorter sorter;
// https://de.wikipedia.org/wiki/Frequenzen_der_gleichstufigen_Stimmung
// Ein Array von 5 Noten !
Note note_array[] = {Note("A2", 110.0), Note("F3", 174.614), Note("A1", 55.0), Note("C5", 523.251), Note("E3", 164.814)};
sorter.sortNotes(note_array, 5);
// Nun sollte das Noten-Array nach Tonhöhe sortiert sein !
for(int i = 0; i < 5; i++){
std::cout << note_array[i].getName() << " : " << note_array[i].getFrequency() << std::endl;
}
return 0;
}
const std::vector<ribi::Music::Note> ribi::Music::Note::GetAllNotes() noexcept
{
std::vector<Note> v;
for (int i=0; i!=12; ++i)
{
v.push_back(Note(i));
}
return v;
}
long
EventFilterDialog::getDurationFromIndex(int index)
{
switch (index) {
// 0
case 11:
return 0;
// 1/96
case 10:
return long(Note(Note::SixtyFourthNote).getDuration() / 3);
// 1/64
case 9 :
return long(Note(Note::SixtyFourthNote).getDuration());
// 1/48
case 8 :
return long(Note(Note::ThirtySecondNote).getDuration() / 3);
// 1/32
case 7 :
return long(Note(Note::ThirtySecondNote).getDuration());
// 1/24
case 6 :
return long(Note(Note::SixteenthNote).getDuration() / 3);
// 1/16
case 5 :
return long(Note(Note::SixteenthNote).getDuration());
// 1/8
case 4 :
return long(Note(Note::EighthNote).getDuration());
// 1/4
case 3 :
return long(Note(Note::QuarterNote).getDuration());
// 1/2
case 2 :
return long(Note(Note::HalfNote).getDuration());
// 1/1
case 1 :
return long(Note(Note::WholeNote).getDuration());
// unlimited
case 0 :
return LONG_MAX;
}
// failsafe
return LONG_MAX;
}
std::wstring WinCommandLink::GetNote()
{
DWORD Length = 0;
SendMessageW(handle, BCM_GETNOTE, reinterpret_cast<WPARAM>(&Length), reinterpret_cast<LPARAM>(&Length));
wchar_t* Buffer = new wchar_t[Length + 1];
SendMessageW(handle, BCM_GETNOTE, reinterpret_cast<WPARAM>(&Length), reinterpret_cast<LPARAM>(Buffer));
std::wstring Note(Buffer);
delete[] Buffer;
return Note;
}
void Sound::next()
{
if (_note != NOTE_LAST)
_note = Note(_note + 1);
else if(_octave != OCTAVE_LAST)
{
_octave = Octave(_octave + 1);
_note = NOTE_FIRST;
}
}
void Sound::prev()
{
if (_note != NOTE_FIRST)
_note = Note(_note - 1);
else if(_octave != OCTAVE_FIRST)
{
_octave = Octave(_octave - 1);
_note = NOTE_LAST;
}
}
void Pattern::ensureBeatNotes()
{
// make sure, that all step-note exist
for( int i = 0; i < m_steps; ++i )
{
bool found = false;
NoteVector::Iterator it;
for( it = m_notes.begin(); it != m_notes.end(); ++it )
{
Note *note = *it;
// if a note in this position is the one we want
if( note->pos() ==
( i * MidiTime::ticksPerTact() ) / MidiTime::stepsPerTact()
&& note->length() <= 0 )
{
found = true;
break;
}
}
if( found == false )
{
addNote( Note( MidiTime( 0 ), MidiTime( ( i *
MidiTime::ticksPerTact() ) /
MidiTime::stepsPerTact() ) ), false );
}
}
// remove notes we no longer need:
// that is, disabled notes that no longer fall to the steps of the new time sig
for( NoteVector::Iterator it = m_notes.begin(); it != m_notes.end(); )
{
bool needed = false;
Note *note = *it;
for( int i = 0; i < m_steps; ++i )
{
if( note->pos() == ( i * MidiTime::ticksPerTact() ) / MidiTime::stepsPerTact()
|| note->length() != 0 )
{
needed = true;
break;
}
}
if( needed == false )
{
delete note;
it = m_notes.erase( it );
}
else {
++it;
}
}
}
