void selectBasedOnModifiers (TreeViewItem* const item, const ModifierKeys& modifiers)
{
TreeViewItem* firstSelected = 0;
if (modifiers.isShiftDown() && ((firstSelected = owner.getSelectedItem (0)) != 0))
{
TreeViewItem* const lastSelected = owner.getSelectedItem (owner.getNumSelectedItems() - 1);
jassert (lastSelected != 0);
int rowStart = firstSelected->getRowNumberInTree();
int rowEnd = lastSelected->getRowNumberInTree();
if (rowStart > rowEnd)
swapVariables (rowStart, rowEnd);
int ourRow = item->getRowNumberInTree();
int otherEnd = ourRow < rowEnd ? rowStart : rowEnd;
if (ourRow > otherEnd)
swapVariables (ourRow, otherEnd);
for (int i = ourRow; i <= otherEnd; ++i)
owner.getItemOnRow (i)->setSelected (true, false);
}
else
{
const bool cmd = modifiers.isCommandDown();
item->setSelected ((! cmd) || ! item->isSelected(), ! cmd);
}
}
void HoaMap::mouseDrag (const MouseEvent &event)
{
Point<float> mouse = event.getPosition().toFloat();
Point<float> newPos;
ModifierKeys modifierKey = event.mods;
// conversion en cartesien :
//mouse.applyTransform(AffineTransform::translation(m_padding, m_padding));
mouse.applyTransform(AffineTransform::fromTargetPoints(0, 0, -1, 1,
getPadWidth(), 0, 1, 1,
getPadWidth(), getPadWidth(), 1, -1));
newPos = mouse;
if (m_sourcePointed >= 0 && m_sourcePointed < m_nbSources) {
setMouseCursor(MouseCursor::DraggingHandCursor);
m_sources_dragState[m_sourcePointed] = -1; // reset dragging state
m_sources_ValueChanged[m_sourcePointed] = 1;
if (modifierKey.isShiftDown()) { // constrain move to distance
setPolarCoordinates(m_sourcePointed, Tools::radius(newPos.x, newPos.y), m_sources[m_sourcePointed].getAzimuth());
}
else if (modifierKey.isCtrlDown()) { // constrain move to angle
setPolarCoordinates(m_sourcePointed, m_sources[m_sourcePointed].getRadius(), Tools::angle(newPos.x, newPos.y));
}
else {
setCartesianCoordinates(m_sourcePointed, newPos.x, newPos.y, sendNotificationSync);
}
}
}
void Ambix_encoderAudioProcessorEditor::modifierKeysChanged(const ModifierKeys &modifiers)
{
if (modifiers.isShiftDown())
{
sld_el->setColour (Slider::thumbColourId, Colours::black);
sld_el->setEnabled(false);
}
else
{
sld_el->setColour (Slider::thumbColourId, Colours::grey);
sld_el->setEnabled(true);
}
if (modifiers.isCtrlDown())
{
sld_az->setColour (Slider::thumbColourId, Colours::black);
sld_az->setEnabled(false);
}
else
{
sld_az->setColour (Slider::thumbColourId, Colours::grey);
sld_az->setEnabled(true);
}
}
void BigClockEditor::buttonClicked (Button* buttonThatWasClicked) {
ModifierKeys mousebutton = ModifierKeys::getCurrentModifiers();
if (!mousebutton.isPopupMenu()) {
if (buttonThatWasClicked==runButton)
{
getFilter()->setParameter(kRunWatch,1.f-getFilter()->getParameter(kRunWatch));
}
else if (buttonThatWasClicked==resetButton)
{
getFilter()->setParameter(kClearWatch,1.f);
}
else if (buttonThatWasClicked==infoLabel)
{
bool samplemode = getFilter()->getParameter(kSamples)>=0.5f;
if (barsbeats && !samplemode) {
barsbeats=false;
getFilter()->setParameter(kBarsBeats, 0.0);
getFilter()->setParameter(kSamples, 0.0);
}
else if (!barsbeats && !samplemode) {
getFilter()->setParameter(kSamples, 1.0);
}
else if (samplemode) {
barsbeats=true;
getFilter()->setParameter(kBarsBeats, 1.0);
getFilter()->setParameter(kSamples, 0.0);
}
updateParametersFromFilter();
}
}
}
void ChannelStripComponent::mouseDown(const MouseEvent &) {
ModifierKeys modifiers = ModifierKeys::getCurrentModifiersRealtime();
// check the mod keys ..
if (modifiers.isPopupMenu() || modifiers.isCtrlDown())
{
ScopedPointer<PopupMenu> arrangeMenu_ = new PopupMenu();
arrangeMenu_->clear();
arrangeMenu_->addCommandItem(&_commands, MainWindow::showArrangement);
arrangeMenu_->show();
}
}
//==============================================================================
// (returns true if the button change caused a modal event loop)
bool setButtons (const Point<int>& screenPos, const Time& time, const ModifierKeys& newButtonState)
{
if (buttonState == newButtonState)
return false;
// (avoid sending a spurious mouse-drag when we receive a mouse-up)
if (! (isDragging() && ! newButtonState.isAnyMouseButtonDown()))
setScreenPos (screenPos, time, false);
// (ignore secondary clicks when there's already a button down)
if (buttonState.isAnyMouseButtonDown() == newButtonState.isAnyMouseButtonDown())
{
buttonState = newButtonState;
return false;
}
const int lastCounter = mouseEventCounter;
if (buttonState.isAnyMouseButtonDown())
{
Component* const current = getComponentUnderMouse();
if (current != nullptr)
{
const ModifierKeys oldMods (getCurrentModifiers());
buttonState = newButtonState; // must change this before calling sendMouseUp, in case it runs a modal loop
sendMouseUp (current, screenPos + unboundedMouseOffset, time, oldMods);
}
enableUnboundedMouseMovement (false, false);
}
buttonState = newButtonState;
if (buttonState.isAnyMouseButtonDown())
{
Desktop::getInstance().incrementMouseClickCounter();
Component* const current = getComponentUnderMouse();
if (current != nullptr)
{
registerMouseDown (screenPos, time, current, buttonState);
sendMouseDown (current, screenPos, time);
}
}
return lastCounter != mouseEventCounter;
}
bool ApplicationSettingsFile::Load(File file)
{
if (!file.exists())
return false;
configFile = file.getFullPathName();
String jsonString = file.loadFileAsString();
var json;
Result result = JSON::parse(jsonString, json);
if (result.ok())
{
DynamicObject* obj = json.getDynamicObject();
if (obj == nullptr)
return false;
if(obj->hasProperty("PlayType"))
setPlayType((SoundPlayType)(int)obj->getProperty("PlayType"));
if (obj->hasProperty("UseGlobalHooks"))
setUseGlobalHooks((bool)obj->getProperty("UseGlobalHooks"));
if (obj->hasProperty("StopAllSoundKeyPresses"))
{
var keyPresses = obj->getProperty("StopAllSoundKeyPresses");
if (keyPresses.isArray())
{
for (int i = 0; i < keyPresses.size(); ++i)
{
var jsonKeyPress(keyPresses[i]);
if (jsonKeyPress.isVoid())
continue;
DynamicObject* jsonKeyPressObj = jsonKeyPress.getDynamicObject();
if (jsonKeyPressObj == nullptr)
continue;
int keyCode = (int)jsonKeyPressObj->getProperty("KeyCode");
int modifierFlags = (int)jsonKeyPressObj->getProperty("ModifierFlags");
juce::juce_wchar textCharacter = (juce_wchar)((int)jsonKeyPressObj->getProperty("TextCharacter"));
ModifierKeys modifierKeys;
modifierKeys = modifierKeys.withFlags(modifierFlags);
KeyPress keyPress(keyCode, modifierKeys, textCharacter);
stopAllSoundsKeys.add(keyPress);
}
}
}
}
return true;
}
void handleTaskBarEvent (const LPARAM lParam)
{
if (owner.isCurrentlyBlockedByAnotherModalComponent())
{
if (lParam == WM_LBUTTONDOWN || lParam == WM_RBUTTONDOWN
|| lParam == WM_LBUTTONDBLCLK || lParam == WM_LBUTTONDBLCLK)
{
Component* const current = Component::getCurrentlyModalComponent();
if (current != nullptr)
current->inputAttemptWhenModal();
}
}
else
{
ModifierKeys eventMods (ModifierKeys::getCurrentModifiersRealtime());
if (lParam == WM_LBUTTONDOWN || lParam == WM_LBUTTONDBLCLK)
eventMods = eventMods.withFlags (ModifierKeys::leftButtonModifier);
else if (lParam == WM_RBUTTONDOWN || lParam == WM_RBUTTONDBLCLK)
eventMods = eventMods.withFlags (ModifierKeys::rightButtonModifier);
else if (lParam == WM_LBUTTONUP || lParam == WM_RBUTTONUP)
eventMods = eventMods.withoutMouseButtons();
const MouseEvent e (Desktop::getInstance().getMainMouseSource(),
Point<int>(), eventMods, &owner, &owner, Time (getMouseEventTime()),
Point<int>(), Time (getMouseEventTime()), 1, false);
if (lParam == WM_LBUTTONDOWN || lParam == WM_RBUTTONDOWN)
{
SetFocus (iconData.hWnd);
SetForegroundWindow (iconData.hWnd);
owner.mouseDown (e);
}
else if (lParam == WM_LBUTTONUP || lParam == WM_RBUTTONUP)
{
owner.mouseUp (e);
}
else if (lParam == WM_LBUTTONDBLCLK || lParam == WM_LBUTTONDBLCLK)
{
owner.mouseDoubleClick (e);
}
else if (lParam == WM_MOUSEMOVE)
{
owner.mouseMove (e);
}
}
}
//==============================================================================
void handleEvent (ComponentPeer* const newPeer, Point<int> positionWithinPeer, Time time, const ModifierKeys newMods)
{
jassert (newPeer != nullptr);
lastTime = time;
++mouseEventCounter;
const Point<int> screenPos (newPeer->localToGlobal (positionWithinPeer));
if (isDragging() && newMods.isAnyMouseButtonDown())
{
setScreenPos (screenPos, time, false);
}
else
{
setPeer (newPeer, screenPos, time);
if (ComponentPeer* peer = getPeer())
{
if (setButtons (screenPos, time, newMods))
return; // some modal events have been dispatched, so the current event is now out-of-date
peer = getPeer();
if (peer != nullptr)
setScreenPos (screenPos, time, false);
}
}
}
//==============================================================================
void handleEvent (ComponentPeer& newPeer, Point<float> positionWithinPeer, Time time,
const ModifierKeys newMods, float newPressure)
{
lastTime = time;
const bool pressureChanged = (pressure != newPressure);
pressure = newPressure;
++mouseEventCounter;
const Point<float> screenPos (newPeer.localToGlobal (positionWithinPeer));
if (isDragging() && newMods.isAnyMouseButtonDown())
{
setScreenPos (screenPos, time, pressureChanged);
}
else
{
setPeer (newPeer, screenPos, time);
if (ComponentPeer* peer = getPeer())
{
if (setButtons (screenPos, time, newMods))
return; // some modal events have been dispatched, so the current event is now out-of-date
peer = getPeer();
if (peer != nullptr)
setScreenPos (screenPos, time, pressureChanged);
}
}
}
void TabBarButton::clicked (const ModifierKeys& mods)
{
if (mods.isPopupMenu())
owner.popupMenuClickOnTab (getIndex(), getButtonText());
else
owner.setCurrentTabIndex (getIndex());
}
void ListBox::selectRowsBasedOnModifierKeys (const int row,
const ModifierKeys& mods,
const bool isMouseUpEvent)
{
if (multipleSelection && mods.isCommandDown())
{
flipRowSelection (row);
}
else if (multipleSelection && mods.isShiftDown() && lastRowSelected >= 0)
{
selectRangeOfRows (lastRowSelected, row);
}
else if ((! mods.isPopupMenu()) || ! isRowSelected (row))
{
selectRowInternal (row, false, ! (multipleSelection && (! isMouseUpEvent) && isRowSelected (row)), true);
}
}
void TrackMixerComponent::buttonStateChanged(Button* button)
{
// if button is clicked mute or solo track
if(button == _muteButton)
_engine.getMixer();
else if(button == _soloButton)
_engine.getMixer()->soloTrack(_trackID);
ModifierKeys modifiers = ModifierKeys::getCurrentModifiersRealtime();
// menu for adding tracks
if (modifiers.isPopupMenu() || modifiers.isCtrlDown())
{
ScopedPointer<PopupMenu> arrangeMenu_ = new PopupMenu();
arrangeMenu_->clear();
arrangeMenu_->addCommandItem(&_commands, ProjectManager::addTrack);
arrangeMenu_->show();
}
}
void registerMouseDown (const Point<int>& screenPos, const Time& time,
Component* const component, const ModifierKeys& modifiers) noexcept
{
for (int i = numElementsInArray (mouseDowns); --i > 0;)
mouseDowns[i] = mouseDowns[i - 1];
mouseDowns[0].position = screenPos;
mouseDowns[0].time = time;
mouseDowns[0].component = component;
mouseDowns[0].buttons = modifiers.withOnlyMouseButtons();
mouseMovedSignificantlySincePressed = false;
}
bool ScumblerComponent::keyPressed(const KeyPress& key)
{
bool retval = false;
if (key.isKeyCode(KeyPress::tabKey))
{
ModifierKeys mod = key.getModifiers();
if (mod.isShiftDown())
{
fScumbler->ActivatePreviousTrack();
}
else
{
fScumbler->ActivateNextTrack();
}
retval = true;
}
else
{
retval = false;
}
return retval;
}
void GuiPiano::buttonClicked(Button *button)
{
//get modifier key so we can handle cmd-clicks when selecting keys
ModifierKeys modifier = ModifierKeys::getCurrentModifiers();
for (int i = 0; i <= 119; i++)
{
if (button == keys[i])
{
//=========================================================================
//=========================================================================
//regular click to set the selected midi pads note or sequencers pad root note
if (modifier.isAnyModifierKeyDown() == false)
{
//first clear all keys
for (int i = 0; i < 120; i++)
setKeyDisplay(i, false);
selectedKeys.clear();
for (int padIndex = 0; padIndex < selectedPads.size(); padIndex++)
{
int padNum = selectedPads[padIndex];
//=========================================================================
//MIDI MODE REG CLICK
if (PAD_SETTINGS->getMode() == 1) //Midi Mode
{
PAD_SETTINGS->setMidiNote(i);
if (padIndex == 0)
{
setKeyDisplay (i, true);
selectedKeys.addIfNotAlreadyThere(i);
noteNumber = i;
}
}
//=========================================================================
//SEQ MODE REG CLICK
else if (PAD_SETTINGS->getMode() == 3) //Sequencer Mode
{
//get currently set 'root' note
int rootNote = PAD_SETTINGS->getSequencerMidiNote(0);
//get difference between root note and clicked note
int transposeValue = rootNote - i;
//check to see if the top row of grid will be transposed
//to above 119. If so, don't transpose the notes, and just
//redraw/re-set what was last there in the below else statement
if (PAD_SETTINGS->getSequencerMidiNote(11)-transposeValue <= 119)
{
//add the transpose value to each note in the scale/set
for (int row = 0; row < 12; row++)
{
int currentVal = PAD_SETTINGS->getSequencerMidiNote(row);
if (currentVal >= 0)
{
int newVal = currentVal-transposeValue;
PAD_SETTINGS->setSequencerMidiNote(newVal, row);
//update the GUI
if (padIndex == 0)
{
setKeyDisplay (newVal, true);
selectedKeys.addIfNotAlreadyThere(newVal);
}
if (row == 0)
noteNumber = i;
}
}
}
else
{
//redraw and re-set what was previously there
//bit convoluted to clear everything above
//just to redraw it in a certain situation.
//Is there a better way to code it?
for (int row = 0; row < 12; row++)
{
if (padIndex == 0)
{
setKeyDisplay (PAD_SETTINGS->getSequencerMidiNote(row), true);
selectedKeys.addIfNotAlreadyThere(PAD_SETTINGS->getSequencerMidiNote(row));
}
}
}
recentlyUpdated = true;
}
}
}
//=========================================================================
//=========================================================================
//cmd-click to select mutiple notes for midi pads or custom scale for sequencer pads
else if (modifier.isCommandDown() == true)
{
//don't intially clear the keys
//=========================================================================
//MIDI MODE CMD-CLICK
//if the number of selected keys is less than the number of selected pads
if (selectedKeys.size() < selectedPads.size())
{
//cycle through the SELECTED KEYS in the order they were selected,
//applying them to the selected pads in the order they were selected.
for (int padIndex = 0; padIndex < selectedKeys.size(); padIndex++)
{
int padNum = selectedPads[padIndex];
if (PAD_SETTINGS->getMode() == 1) //Midi Mode
{
PAD_SETTINGS->setMidiNote(selectedKeys[padIndex]);
//update the GUI
if (padIndex == 0)
{
//add the key
setKeyDisplay (i, true);
selectedKeys.addIfNotAlreadyThere(i);
noteNumber = selectedKeys[0];
}
}
}
}
//=========================================================================
//SEQ MODE CMD-CLICK
for (int padIndex = 0; padIndex < selectedPads.size(); padIndex++)
{
int padNum = selectedPads[padIndex];
if (PAD_SETTINGS->getMode() == 3) //Sequencer Mode
{
/*
Cmd-click is used to select a custom scale/set of notes for a the sequence grid of a sequencer pad.
Click on an unselected key to add it, click on a selected key to remove it.
The selected keys/notes will be applied in order of their value to the sequencer rows.
If less than 12 notes are selected, the top 'unselected' rows will note have any notes on them.
This is the current way that the app handles command-clicks on the piano in seq mode:
When the user cmd-clicks a key for the first time (when recentlyUpdated == true) it will clear the piano
and allow the user to select 12 individual different keys for each row if the sequence.
Each time a key is selected it orders the selectedkey array and
applies all the selected keys to the sequence rows.
If the number of selected keys is less than the number of rows (12), each row which
doesn't currently have a key selected for it is set to an 'off' value of -500.
I've chosen 500 as no degree of transposing a note set to -500 could be transposed to
be positive by regualar clicking the piano).
The app will view any minus midi note number as 'off', whether its to display the note on the piano
or play the note as a midi message.
This method seems to make more sense over the other possible methods:
1. any 'unchosen' note is set to a default note such as 0 or 60. This is flawed as when transposing
the selection it will transpose the default note which might not make sense, plus when
ordering the selected keys the default note could be layed out somewhere in the middle of the
selected notes, which doesn't make sense as any unselected notes should be set to the top of the grid.
2. any 'unchosen' note is kept the same as the previous note. This also flawed because of the
second reason in the point above.
*/
//=========== click on unselected key ===============
if (keys[i]->getToggleState() == true) //if was previous off and clicked
{
if (recentlyUpdated == true && selectedKeys.size() == 12) // so th cmd-click doesn't delete if incomplete set
{
if (padIndex == 0)
{
//clear all keys
for (int i = 0; i < 120; i++)
setKeyDisplay(i, false);
selectedKeys.clear();
}
}
recentlyUpdated = false;
//if the number of selected keys is less than the number of sequencer rows
if (selectedKeys.size() < 12)
{
//update the GUI
if (padIndex == 0)
{
setKeyDisplay (i, true);
selectedKeys.addIfNotAlreadyThere(i);
//sort selectedKeys into order.
//The below loop checks the recently added key/note
//and compares in to the previous key and moves
//it to the correct location in the array
for (int x = selectedKeys.size() - 1; x >= 0; x--)
{
if (selectedKeys[x] < selectedKeys[x-1])
{
selectedKeys.swap(x, x-1);
}
}
}
for (int row = 0; row < 12; row++)
{
int note = selectedKeys[row];
if (row > selectedKeys.size()-1)
note = -500; //'off' note
PAD_SETTINGS->setSequencerMidiNote(note, row);
}
}
}
//=========== click on selected key ===============
else if (keys[i]->getToggleState() == false) //if was previous on and clicked
{
recentlyUpdated = false;
//update the GUI (only need to do this a single time)
if (padIndex == 0)
{
setKeyDisplay (i, false);
selectedKeys.removeFirstMatchingValue(i);
//Don't need to sort keys here do I?
//Removing an element will resize the array,
//which will cause the top row to be set to note 'off'
}
for (int row = 0; row < 12; row++)
{
int note = selectedKeys[row];
if (row > selectedKeys.size()-1)
note = -500; //'off' note
PAD_SETTINGS->setSequencerMidiNote(note, row);
}
}
noteNumber = selectedKeys[0];
}
}
}
//=========================================================================
//=========================================================================
//alt-click to transpose mutiple notes for midi pads
else if (modifier.isAltDown() == true)
{
if (AppSettings::Instance()->padSettings[selectedPads[0]]->getMode() == 1) //Midi Mode
{
//clear all keys
for (int i = 0; i < 120; i++)
setKeyDisplay(i, false);
selectedKeys.clear();
//At the moment the currentl alg. belows won't allow you to transpose a scale
//if ANY note will be transposed to above 119. Also, when transposing the note
//you select will be the lowest note. However in the old software it was possible
//to transpose notational arrangements so that the bottom set of notes would all
//equal 0 or the top sets would all equal 119, meaning you could have more choice
//over where the arrangment starts and ends. Do we want that here? If so, the below
//code will need to be changed to how it was before (most of it has just been
//commented out.
//Get the 'root note'.
//Should the root note be the note of the first select pad (selectedPads[0]).
//Or should it be the lowest note?
//Below is the code to find the lowest note.
Array <int> selectedPadsNotes;
for (int padIndex = 0; padIndex < selectedPads.size(); padIndex++)
selectedPadsNotes.insert(padIndex,
AppSettings::Instance()->padSettings[selectedPads[padIndex]]->getMidiNote());
DefaultElementComparator<int> sorter;
selectedPadsNotes.sort (sorter);
int rootNote = selectedPadsNotes[0];
//get difference between root note and clicked note
int transposeValue = rootNote - i;
//check to see if the highest note will be transposed
//to above 119. If so, don't transpose the notes, and just
//redraw/re-set what was last there in the below else statement
if (selectedPadsNotes.getLast()-transposeValue <= 119)
{
for (int padIndex = 0; padIndex < selectedPads.size(); padIndex++)
{
int padNum = selectedPads[padIndex];
int currentVal = PAD_SETTINGS->getMidiNote();
int newVal = currentVal-transposeValue;
//if (newVal > 119)
//newVal = 119;
//else if (newVal < 0)
//newVal = 0;
PAD_SETTINGS->setMidiNote(newVal);
//update the GUI
setKeyDisplay (newVal, true);
selectedKeys.addIfNotAlreadyThere(newVal);
if (padIndex == 0)
noteNumber = newVal;
}
}
else
{
//redraw and re-set what was previously there
//bit convoluted to clear everything above
//just to redraw it in a certain situation.
//Is there a better way to code it?
for (int padIndex = 0; padIndex < selectedPads.size(); padIndex++)
{
int padNum = selectedPads[padIndex];
setKeyDisplay (PAD_SETTINGS->getMidiNote(), true);
selectedKeys.addIfNotAlreadyThere(PAD_SETTINGS->getMidiNote());
}
}
}
}
break;
//=========================================================================
//=========================================================================
}
}
}
void MouseInputSource::handleEvent (ComponentPeer* peer, const Point<int>& positionWithinPeer,
const int64 time, const ModifierKeys& mods)
{
pimpl->handleEvent (peer, positionWithinPeer, Time (time), mods.withOnlyMouseButtons());
}
bool MoveAwayForFineAdjustmentSlider::isAbsoluteDragMode (ModifierKeys mods) const
{
return getVelocityBasedMode() == (getVelocityModeIsSwappable()
&& mods.testFlags (ModifierKeys::ctrlAltCommandModifiers));
}
void TrackComponent::mouseDown(const MouseEvent &e) {
ModifierKeys modifiers = ModifierKeys::getCurrentModifiersRealtime();
int posX;
// check the mod keys ..
if (modifiers.isPopupMenu() || modifiers.isCtrlDown())
{
ScopedPointer<PopupMenu> trackMenu_ = new PopupMenu();
trackMenu_->clear();
trackMenu_->addCommandItem(&_commands, MainWindow::showMixer);
trackMenu_->addItem(1, "Add Region", true);
MouseEvent ev = e.getEventRelativeTo(this);
for(auto region : _regionComponents)
{
posX = ev.x;
region->setBroughtToFrontOnMouseClick(true);
if(region->getPositionX() < posX && posX < (region->getPositionX() + region->getRegionWidth()))
{
trackMenu_->addItem(2, "Remove Region", true);
}
}
switch (trackMenu_->show())
{
case 1:
{
FileChooser chooser("Select an audio file to add...",
File::nonexistent,
"*.wav; *aif; *.flac");
if (chooser.browseForFileToOpen()) {
File audioFile(chooser.getResult());
const String fileString = audioFile.getFullPathName();
String format;
if (fileString.contains(".wav"))
format = "WAV";
else if (fileString.contains(".aif") || fileString.contains(".aiff"))
format = "AIFF";
else if (fileString.contains(".flac"))
format = "FLAC";
AudioFormatManager formatManager;
formatManager.registerBasicFormats();
AudioFormatReader* reader = formatManager.createReaderFor(audioFile);
Audio::Region* region = new Audio::SampleRegion(reader, 1, &audioFile);
Point<int> position = e.getPosition();
int x = position.getX();
if (x > _mixerOffset)
{
int64 samplesRange = secondsToSamples(100, _sampleRate);
int64 positionSamples = pixelsToSamples(x - _mixerOffset, 100 * _pixelsPerClip, samplesRange);
_track->add(positionSamples, region);
createRegionGUI(x, region, formatManager, audioFile);
getParentComponent()->resized();
}
else if (x < _mixerOffset)
{
_track->add(0, region);
createRegionGUI(_mixerOffset, region, formatManager, audioFile);
getParentComponent()->resized();
}
}
}
break;
case 2:
{
CriticalSection critical;
critical.enter();
for(size_t i = 0; i < _regionComponents.size(); ++i)
{
Rectangle<int> bounds_ = _regionComponents.at(i)->getBounds();
posX = ev.x;
if((int)_regionComponents.at(i)->getPositionX() < posX && posX < ((int)_regionComponents.at(i)->getPositionX() + (int)_regionComponents.at(i)->getRegionWidth()))
{
_track->remove(_regionComponents.at(i)->getRegion(), _posX.at(i));
std::vector<RegionComponent*>::iterator regit = _regionComponents.begin() + i;
RegionComponent* component = _regionComponents.at(i);
removeChildComponent(_regionComponents.at(i));
_regionComponents.erase(regit);
delete component;
_regions.erase(_posX.at(i));
std::vector<int64>::iterator posit = _posX.begin() + i;;
_posX.erase(posit);
std::vector<int64>::iterator sampsit = _sizeSamps.begin() + i;;
_sizeSamps.erase(sampsit);
}
}
critical.exit();
}
default:
break;
}
}
}
void BigClockEditor::buttonStateChanged (Button* buttonThatWasClicked) {
if (buttonThatWasClicked->isDown()) {
ModifierKeys mousebutton = ModifierKeys::getCurrentModifiers();
if (mousebutton.isPopupMenu()) {
bool samplemode = getFilter()->getParameter(kSamples)>=0.5f;
PopupMenu m, sub1,sub2,sub3,sub4,clockmode;
sub1.addCustomItem (-1, colourSelector, 300, 300, false);
m.addSubMenu (L"Color", sub1);
m.addSeparator();
clockmode.addItem(100,"Host Timeline",true,getFilter()->mode == HostTimeMode);
clockmode.addItem(101,"Recording Time",true,getFilter()->mode == RecTimeMode);
clockmode.addItem(102,"Stopwatch",true,getFilter()->mode == StopwatchMode);
clockmode.addItem(103,"Plugin Time",true,getFilter()->mode == PluginTimeMode);
clockmode.addItem(104,"Actual Time",true,getFilter()->mode == ActualTimeMode);
m.addSubMenu("Clock Mode",clockmode);
m.addItem(120,"Reset",getFilter()->mode != HostTimeMode && getFilter()->mode != ActualTimeMode);
m.addSeparator();
sub4.addItem(998,L"Show Cues",true,showtextbox);
sub4.addItem(996,L"Import...");
sub4.addItem(997,L"Export...",getFilter()->cues.size()>0);
sub4.addItem(999,L"Clear",getFilter()->cues.size()>0);
for (int i=0;i<getFilter()->cues.size();i++) {
sub4.addItem(1000+i,
getFilter()->ppqToString(getFilter()->cues[i]->ppq,
getFilter()->lastPosInfo.timeSigNumerator,
getFilter()->lastPosInfo.timeSigDenominator,
getFilter()->lastPosInfo.bpm,barsbeats)
+ " - " + getFilter()->cues[i]->text,true,getFilter()->cues[i]->enabled);
}
m.addSubMenu (L"Cues", sub4, getFilter()->mode==HostTimeMode);
m.addSeparator();
m.addItem (3, L"Bars|Beats|Ticks", true, barsbeats && !samplemode);
float ppqn = getFilter()->getParameter(kTicks);
sub2.addItem(30,L"hide ticks",true,ppqn==1.0);
sub2.addItem(31,L"4",true,ppqn<1.0 && ppqn>=0.9);
sub2.addItem(32,L"16",true,ppqn<0.9 && ppqn>=0.8);
sub2.addItem(33,L"48",true,ppqn<0.8 && ppqn>=0.7);
sub2.addItem(34,L"96",true,ppqn<0.7 && ppqn>=0.65);
sub2.addItem(35,L"100",true,ppqn<0.65 && ppqn>=0.6);
sub2.addItem(36,L"120",true,ppqn<0.6 && ppqn>=0.5);
sub2.addItem(37,L"192",true,ppqn<0.5 && ppqn>=0.4);
sub2.addItem(38,L"240",true,ppqn<0.4 && ppqn>=0.3);
sub2.addItem(39,L"384",true,ppqn<0.3 && ppqn>=0.2);
sub2.addItem(40,L"480",true,ppqn<0.2 && ppqn>=0.1);
sub2.addItem(41,L"768",true,ppqn<0.1 && ppqn>0.0);
sub2.addItem(42,L"960",true,ppqn==0.0);
m.addSubMenu (L"Ticks per beat", sub2,barsbeats && !samplemode);
m.addSeparator();
m.addItem (4, L"Hour:Min:Sec", true, !barsbeats && !samplemode);
float fps = getFilter()->getParameter(kFrames);
sub3.addItem(50,L"ms (1000)",true,fps==0.0);
sub3.addItem(51,L"120",true,fps==1.0);
sub3.addItem(52,L"100",true,fps<1.0 && fps>=0.9);
sub3.addItem(53,L"75",true,fps<0.9 && fps>=0.8);
sub3.addItem(54,L"60",true,fps<0.8 && fps>=0.7);
sub3.addItem(55,L"50",true,fps<0.7 && fps>=0.6);
sub3.addItem(56,L"30",true,fps<0.6 && fps>=0.5);
sub3.addItem(61,L"29.97 drop",true,fps<0.5 && fps>=0.4);
sub3.addItem(57,L"25",true,fps<0.4 && fps>=0.3);
sub3.addItem(58,L"24",true,fps<0.3 && fps>=0.2);
sub3.addItem(59,L"15",true,fps<0.2 && fps>=0.1);
sub3.addItem(60,L"10",true,fps<0.1 && fps>0.0);
m.addSubMenu (L"Frames per second", sub3, !barsbeats && !samplemode);
m.addItem (1, L"Show ms/frames", !barsbeats && !samplemode, getFilter()->getParameter(kShowms)>=0.5);
m.addItem (6, L"Show subframes", !barsbeats && !samplemode && getFilter()->getParameter(kShowms)>=0.5, getFilter()->getParameter(kShowsubfr)>=0.5);
m.addItem (2, L"Show hours", !barsbeats && !samplemode, getFilter()->getParameter(kShowhrs)>=0.5);
m.addSeparator();
m.addItem (5, L"Samples", true, samplemode);
int result = m.show();
if (result > 0)
{
if (result==1) {
if (getFilter()->getParameter(kShowms)>=0.5) getFilter()->setParameter(kShowms,0.0);
else getFilter()->setParameter(kShowms,1.0);
}
else if (result==2) {
if (getFilter()->getParameter(kShowhrs)>=0.5f) getFilter()->setParameter(kShowhrs,0.0f);
else getFilter()->setParameter(kShowhrs,1.0f);
}
else if (result==3) {
if (barsbeats && !samplemode) { }
else {
getFilter()->setParameter(kBarsBeats,1.0f);
getFilter()->setParameter(kSamples,0.0f);
}
}
else if (result>=30 && result<50) {
if (result==30) getFilter()->setParameter(kTicks,1.0f);
else if (result==31) getFilter()->setParameter(kTicks,0.91f);
else if (result==32) getFilter()->setParameter(kTicks,0.81f);
else if (result==33) getFilter()->setParameter(kTicks,0.71f);
else if (result==34) getFilter()->setParameter(kTicks,0.65f);
else if (result==35) getFilter()->setParameter(kTicks,0.61f);
else if (result==36) getFilter()->setParameter(kTicks,0.51f);
else if (result==37) getFilter()->setParameter(kTicks,0.41f);
else if (result==38) getFilter()->setParameter(kTicks,0.31f);
else if (result==39) getFilter()->setParameter(kTicks,0.21f);
else if (result==40) getFilter()->setParameter(kTicks,0.11f);
else if (result==41) getFilter()->setParameter(kTicks,0.051f);
else if (result==42) getFilter()->setParameter(kTicks,0.0f);
}
else if (result==4) {
if (!barsbeats && !samplemode) { }
else {
getFilter()->setParameter(kBarsBeats,0.0f);
getFilter()->setParameter(kSamples,0.0f);
}
}
else if (result>=50 && result<70) {
if (result==50) getFilter()->setParameter(kFrames,0.0f);
else if (result==51) getFilter()->setParameter(kFrames,1.0f);
else if (result==52) getFilter()->setParameter(kFrames,0.9f);
else if (result==53) getFilter()->setParameter(kFrames,0.8f);
else if (result==54) getFilter()->setParameter(kFrames,0.7f);
else if (result==55) getFilter()->setParameter(kFrames,0.6f);
else if (result==56) getFilter()->setParameter(kFrames,0.5f);
else if (result==61) getFilter()->setParameter(kFrames,0.4f);
else if (result==57) getFilter()->setParameter(kFrames,0.3f);
else if (result==58) getFilter()->setParameter(kFrames,0.2f);
else if (result==59) getFilter()->setParameter(kFrames,0.1f);
else if (result==60) getFilter()->setParameter(kFrames,0.05f);
}
else if (result==5) {
if (!samplemode) getFilter()->setParameter(kSamples,1.0f);
}
else if (result==6) {
getFilter()->setParameter(kShowsubfr,getFilter()->getParameter(kShowsubfr)>=0.5f?0.0f:1.0f);
}
else if (result==100)
{
getFilter()->setParameter(kClockMode,0.f);
}
else if (result==101)
{
getFilter()->setParameter(kClockMode,1.f/(float)(numModes-1));
}
else if (result==102)
{
getFilter()->setParameter(kClockMode,2.f/(float)(numModes-1));
}
else if (result==103)
{
getFilter()->setParameter(kClockMode,3.f/(float)(numModes-1));
}
else if (result==104)
{
getFilter()->setParameter(kClockMode,4.f/(float)(numModes-1));
}
else if (result==120) {
if (getFilter()->mode==StopwatchMode)
getFilter()->setParameter(kClearWatch,1.f);
else if (getFilter()->mode==RecTimeMode)
getFilter()->rectime=0;
else if (getFilter()->mode==PluginTimeMode)
getFilter()->plugintime=Time::getMillisecondCounter();
}
else if (result==998) {
getFilter()->showcues=!showtextbox;
updateParametersFromFilter();
resized();
repaint();
}
else if (result==996) {
FileChooser myChooser ("Import cue file...",
File(getFilter()->getCurrentPath()),
"*.xml");
if (myChooser.browseForFileToOpen())
{
File file (myChooser.getResult());
getFilter()->loadCues(file);
}
}
else if (result==997) {
FileChooser myChooser ("Export cue file...",
File(getFilter()->getCurrentPath() + File::separatorString + "cues.xml"));
if (myChooser.browseForFileToSave(true))
{
File cuefile (myChooser.getResult());
if (!cuefile.hasFileExtension("xml")) cuefile = cuefile.withFileExtension("xml");
getFilter()->saveCues(cuefile);
}
}
else if (result==999) {
getFilter()->cues.clear();
cueLabel->setText(String::empty,false);
}
else if (result>=1000) {
getFilter()->setCueEnabled(result-1000,!(getFilter()->cues[result-1000]->enabled));
updateParametersFromFilter();
}
}
}
}
}
