void SliderBank::mouseDrag (const MouseEvent& event)
{
// choose slider to operate on
MicronSlider* slider = 0;
if (lockedSliderBeingDragged)
slider = lockedSliderBeingDragged;
else
if ( event.getPosition().getX() >= minBoundX && event.getPosition().getX() < maxBoundX )
slider = findSliderAtPos(event.getPosition());
if ( ! slider )
return; // no slider
if (slider != prevSlider)
{ // different slider from last time
if (resettingValuesToDefault)
{ // reset slider to default value
bool dummy;
slider->setValue(slider->getDoubleClickReturnValue(dummy));
}
else
{ // set slider value at mouse position
slider->resetDoubleClickTimer(); // ensure we don't reset sliders just by dragging back and forth over them
slider->mouseDown(event.getEventRelativeTo(slider));
}
}
else
{ // same slider as last time
if ( ! resettingValuesToDefault )
slider->mouseDrag(event.getEventRelativeTo(slider));
}
prevSlider = slider;
}
bool Viewport::useMouseWheelMoveIfNeeded (const MouseEvent& e, float wheelIncrementX, float wheelIncrementY)
{
if (! (e.mods.isAltDown() || e.mods.isCtrlDown()))
{
const bool hasVertBar = verticalScrollBar->isVisible();
const bool hasHorzBar = horizontalScrollBar->isVisible();
if (hasHorzBar && (wheelIncrementX != 0 || e.mods.isShiftDown() || ! hasVertBar))
{
if (wheelIncrementX == 0 && ! hasVertBar)
wheelIncrementX = wheelIncrementY;
horizontalScrollBar->mouseWheelMove (e.getEventRelativeTo (horizontalScrollBar),
wheelIncrementX, wheelIncrementY);
return true;
}
else if (hasVertBar && wheelIncrementY != 0)
{
verticalScrollBar->mouseWheelMove (e.getEventRelativeTo (verticalScrollBar),
wheelIncrementX, wheelIncrementY);
return true;
}
}
return false;
}
void DiagramToolbar::mouseDrag(const MouseEvent& e)
{
if (!_parent->isValidComponent())
{
delete this;
}
else
{
MouseEvent e2 (e.getEventRelativeTo(_parent));
// if the mouse is inside the parent component, we'll make that the
// parent - otherwise, we'll put this comp on the desktop.
if (e2.x >= 0 && e2.y >= 0 && e2.x < _parent->getWidth() && e2.y < _parent->getHeight())
{
// re-add this component to a parent component, which will
// remove it from the desktop..
_parent->addChildComponent(this);
}
else
{
// add the component to the desktop, which will remove it
// from its current parent component..
addToDesktop(ComponentPeer::windowIsTemporary | ComponentPeer::windowHasDropShadow);
}
_dragger.dragComponent (this, e);
}
}
void TrackComponent::mouseDrag(const MouseEvent &e)
{
int posX;
if(_regionComponents.size() != 0)
{
MouseEvent ev = e.getEventRelativeTo(this);
posX = ev.x;
for (std::size_t i = 0; i != _regionComponents.size(); ++i)
{
_regionComponents.at(i)->toFront(true);
int distance = ev.getDistanceFromDragStartX();
Rectangle<int> r = _regionComponents.at(i)->getBounds();
if(_regionComponents.at(i)->getPositionX() < posX && posX < (_regionComponents.at(i)->getPositionX() + _regionComponents.at(i)->getRegionWidth()))
{
int newPos = r.getX() + distance;
int newEnd = r.getX() + distance + r.getWidth();
_posX.at(i) = newPos;
_regionComponents.at(i)->setBounds(newPos, 0, newEnd - newPos, getHeight());
resized();
int64 samplesRange = secondsToSamples(static_cast<double>(_numberOfClips), _sampleRate);
int64 positionSamples = pixelsToSamples(newPos - _mixerOffset, _numberOfClips * _pixelsPerClip, samplesRange);
int64 widthInSamples = pixelsToSamples(newEnd - _mixerOffset, _numberOfClips * _pixelsPerClip, samplesRange);
_track->setTotalLength(widthInSamples);
_track->move(_regionComponents.at(i)->getRegion(), positionSamples);
if(_posX.at(i) < _mixerOffset)
{
_posX.at(i) = getX() + _mixerOffset ;
_track->move(_regionComponents.at(i)->getRegion(), 0);
resized();
}
}
else if((getComponentAt(e.x, e.y ) == _regionComponents.at(i)))
{
if(ev.x > _mixerOffset)
{
int newPos = r.getX() + distance;
int newEnd = r.getX() + distance + r.getWidth();
_posX.at(i) = newPos;
resized();
Region* region = _regionComponents.at(i)->getRegion();
region->setNextReadPosition(0);
int64 samplesRange = secondsToSamples((double)_numberOfClips, _sampleRate);
int64 positionSamples = pixelsToSamples(newPos - _mixerOffset, _numberOfClips * _pixelsPerClip, samplesRange);
int64 widthInSamples = pixelsToSamples(newEnd - _mixerOffset, _numberOfClips * _pixelsPerClip, samplesRange);
_track->setTotalLength(widthInSamples);
_track->move(region, positionSamples);
if(_posX.at(i) < _mixerOffset)
{
_posX.at(i) = getX() + _mixerOffset ;
_track->move(region, 0);
resized();
}
}
}
}
}
}
void MenuBarComponent::mouseDrag (const MouseEvent& e)
{
const MouseEvent e2 (e.getEventRelativeTo (this));
const int item = getItemAt (e2.getPosition());
if (item >= 0)
showMenu (item);
}
//==============================================================================
void ComponentDragger::startDraggingComponent (Component* const componentToDrag, const MouseEvent& e)
{
jassert (componentToDrag != nullptr);
jassert (e.mods.isAnyMouseButtonDown()); // The event has to be a drag event!
if (componentToDrag != nullptr)
mouseDownWithinTarget = e.getEventRelativeTo (componentToDrag).getMouseDownPosition();
}
void ListBox::mouseMove (const MouseEvent& e)
{
if (mouseMoveSelects)
{
const MouseEvent e2 (e.getEventRelativeTo (this));
selectRow (getRowContainingPosition (e2.x, e2.y), true);
}
}
void mouseWheelMove (const MouseEvent& e, float ix, float iy)
{
// unhandled mouse wheel moves can be referred upwards to the parent comp..
Component* const p = magnifierComp->getParentComponent();
if (p != 0)
p->mouseWheelMove (e.getEventRelativeTo (p), ix, iy);
}
void EnvelopeComponent::mouseDrag(const MouseEvent& e)
{
#ifdef MYDEBUG
printf("MyEnvelopeComponent::mouseDrag(%d, %d)\n", e.x, e.y);
#endif
if(draggingHandle != 0)
draggingHandle->mouseDrag(e.getEventRelativeTo(draggingHandle));
}
void MouseInactivityDetector::wakeUp (const MouseEvent& e, bool alwaysWake)
{
const Point<int> newPos (e.getEventRelativeTo (&targetComp).getPosition());
if ((! isActive) && (alwaysWake || e.source.isTouch() || newPos.getDistanceFrom (lastMousePos) > 15))
setActive (true);
lastMousePos = newPos;
startTimer (delayMs);
}
void EnvelopeComponent::mouseDown(const MouseEvent& e)
{
#ifdef MYDEBUG
printf("MyEnvelopeComponent::mouseDown(%d, %d)\n", e.x, e.y);
#endif
if(e.mods.isShiftDown())
{
// not needed ?
}
else if(e.mods.isCtrlDown())
{
if(getAllowCurveEditing())
{
float timeAtClick = convertPixelsToDomain(e.x);
int i;
EnvelopeHandleComponent* handle = 0;
for(i = 0; i < handles.size(); i++) {
handle = handles.getUnchecked(i);
if(handle->getTime() > timeAtClick)
break;
}
if(PopupComponent::getActivePopups() < 1)
{
EnvelopeHandleComponent* prev = handle->getPreviousHandle();
if(!prev)
{
EnvelopeCurvePopup::create(handle, getScreenX()+e.x, getScreenY()+e.y);
}
else
{
EnvelopeCurvePopup::create(handle,
(handle->getScreenX() + prev->getScreenX())/2,
jmax(handle->getScreenY(), prev->getScreenY())+10);
}
}
}
}
else
{
draggingHandle = addHandle(e.x,e.y, EnvCurve::Linear);
if(draggingHandle != 0) {
setMouseCursor(MouseCursor::NoCursor);
draggingHandle->mouseDown(e.getEventRelativeTo(draggingHandle));
draggingHandle->updateLegend();
}
}
}
void GUI::DockHolder::mouseExit (const MouseEvent &e)
{
if(!lockAutomaticAnimation)
{
const int x = e.getEventRelativeTo (this).x;
const int y = e.getEventRelativeTo (this).y;
const int w = getWidth ();
const int h = getHeight ();
if (!docked && open)
{
switch (orientation)
{
case TOP:
if (y > h &&
(x > 0 ||
x < w))
open = false;
break;
case LEFT:
if (x > w ||
y < 0 ||
y > h)
open = false;
break;
case RIGHT:
if (x < 0 ||
y < 0 ||
y > h)
open = false;
break;
}
}
if (!docked)
{
if (!open)
{
animator.fadeOut (this, FADEOUTMS);
if (panel)
animator.fadeOut (panel->content, FADEOUTMS);
}
}
else
{
if (inside)
{
animator.fadeOut (this, FADEOUTMS);
if (panel)
animator.fadeOut (panel->content, FADEOUTMS);
}
}
inside = false;
}
}
void PianoGridNote::mouseUp (const MouseEvent& e)
{
if (owner)
{
SelectedItemSet<MidiGridItem*> selection = owner->getLassoSelection ();
if (e.mods.isLeftButtonDown())
{
if (isResizing)
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
PianoGridNote* component = dynamic_cast<PianoGridNote*>(selection.getSelectedItem (i));
if (component)
component->endResizing (e);
}
}
else if (isDragging)
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
MidiGridItem* component = selection.getSelectedItem (i);
component->endDragging (e);
}
}
repaint ();
}
else if (e.mods.isMiddleButtonDown())
{
if (isEditingVelocity)
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
PianoGridNote* component = dynamic_cast<PianoGridNote*>(selection.getSelectedItem (i));
if (component)
component->endVelocity (component == this ? e : e.getEventRelativeTo (component));
}
}
}
else if (e.mods.isRightButtonDown())
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
PianoGridNote* component = dynamic_cast<PianoGridNote*>(selection.getSelectedItem (i));
if (component && component != this)
owner->removeNote (component, true);
}
owner->removeNote (this, false);
delete (this);
}
}
}
void MenuBarComponent::mouseDown (const MouseEvent& e)
{
if (currentPopupIndex < 0)
{
const MouseEvent e2 (e.getEventRelativeTo (this));
updateItemUnderMouse (e2.getPosition());
currentPopupIndex = -2;
showMenu (itemUnderMouse);
}
}
void MenuBarComponent::mouseUp (const MouseEvent& e)
{
const MouseEvent e2 (e.getEventRelativeTo (this));
updateItemUnderMouse (e2.getPosition());
if (itemUnderMouse < 0 && getLocalBounds().contains (e2.x, e2.y))
{
setOpenItem (-1);
PopupMenu::dismissAllActiveMenus();
}
}
void MouseInactivityDetector::wakeUp (const MouseEvent& e, bool alwaysWake)
{
auto newPos = e.getEventRelativeTo (&targetComp).getPosition();
if ((! isActive) && (alwaysWake || e.source.isTouch() || newPos.getDistanceFrom (lastMousePos) > toleranceDistance))
setActive (true);
if (lastMousePos != newPos)
{
lastMousePos = newPos;
startTimer (delayMs);
}
}
void SequencerComponent::handleMouseEvent (const MouseEvent& e, bool alwaysToggle)
{
Component *c = getComponentAt (e.getEventRelativeTo(this).getPosition());
CellComponent *cellComponent = dynamic_cast<CellComponent*> (c);
if (cellComponent != 0) {
if ((!alwaysToggle) &&
(cellComponent == lastToggledCellComponent)) {
return;
}
cellComponent->toggleNote();
lastToggledCellComponent = cellComponent;
}
}
void ComboBox::mouseUp (const MouseEvent& e2)
{
if (isButtonDown)
{
isButtonDown = false;
repaint();
const MouseEvent e (e2.getEventRelativeTo (this));
if (reallyContains (e.getPosition(), true)
&& (e2.eventComponent == this || ! label->isEditable()))
{
showPopupIfNotActive();
}
}
}
void BookmarkFolder::mouseUp(const MouseEvent& event)
{
if (!validRect.contains(event.getEventRelativeTo(this).getMouseDownPosition()) )
{
return;
}
if (event.mods.isPopupMenu())//.getCurrentModifiers().
{
if (0 == item["name"].toString().compare(LoadDtdData::getInstance()->getEntityFromDtds("bookmark.notclassify")))
{
return;
}
PopupMenu popMenu;
popMenu.dismissAllActiveMenus();
popMenu.addItem(3101, LoadDtdData::getInstance()->getEntityFromDtds("menu.newfolder"));
if (3101 == popMenu.show())
{
var newFolder = JSON::parse("{}");
newFolder.getDynamicObject()->setProperty("name",
LoadDtdData::getInstance()->getEntityFromDtds("menu.newfolder"));
newFolder.getDynamicObject()->setProperty("content", String::empty);
var childFdr;
childFdr.append(newFolder);
addSubFolders(childFdr);
}
}
else
{
if (item["name"].toString().isEmpty())
{
return;
}
bSelected = true;
childFolders->unSelectedChildren();
std::vector<String> selected;
selected.push_back(item["name"]);
if (selectedFolderListener != nullptr)
{
selectedFolderListener->onSelectedFolderChanged(selected);
}
else
{
((BookmarkFolderContainer*)getParentComponent())->onSelectedFolderChanged(selected);
}
}
}
void GraphEditorPanel::dragConnector (const MouseEvent& e)
{
const MouseEvent e2 (e.getEventRelativeTo (this));
if (draggingConnector != nullptr)
{
draggingConnector->setTooltip (String::empty);
int x = e2.x;
int y = e2.y;
PinComponent* const pin = findPinAt (x, y);
if (pin != nullptr)
{
uint32 srcFilter = draggingConnector->sourceFilterID;
int srcChannel = draggingConnector->sourceFilterChannel;
uint32 dstFilter = draggingConnector->destFilterID;
int dstChannel = draggingConnector->destFilterChannel;
if (srcFilter == 0 && ! pin->isInput)
{
srcFilter = pin->filterID;
srcChannel = pin->index;
}
else if (dstFilter == 0 && pin->isInput)
{
dstFilter = pin->filterID;
dstChannel = pin->index;
}
if (graph.canConnect (srcFilter, srcChannel, dstFilter, dstChannel))
{
x = pin->getParentComponent()->getX() + pin->getX() + pin->getWidth() / 2;
y = pin->getParentComponent()->getY() + pin->getY() + pin->getHeight() / 2;
draggingConnector->setTooltip (pin->getTooltip());
}
}
if (draggingConnector->sourceFilterID == 0)
draggingConnector->dragStart (x, y);
else
draggingConnector->dragEnd (x, y);
}
}
void AutomationEvent::mouseDown (const MouseEvent& e)
{
if (! owner) return;
SelectedItemSet<MidiGridItem*> selection = owner->getLassoSelection ();
if (! selection.isSelected (this))
owner->selectNote (this, true);
if (e.mods.isLeftButtonDown())
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
MidiGridItem* component = selection.getSelectedItem (i);
component->startDragging (component == this ? e : e.getEventRelativeTo (component));
owner->repaint();
}
}
}
void PianoGridNote::mouseDown (const MouseEvent& e)
{
if (! owner) return;
SelectedItemSet<MidiGridItem*> selection = owner->getLassoSelection ();
if (! selection.isSelected (this))
{
owner->selectNote (this, !e.mods.isShiftDown());
selection = owner->getLassoSelection();
}
if (e.mods.isLeftButtonDown())
{
if (e.x >= getWidth() - 2)
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
PianoGridNote* component = dynamic_cast<PianoGridNote*>(selection.getSelectedItem (i));
if (component)
component->startResizing (e);
}
}
else
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
MidiGridItem* component = selection.getSelectedItem (i);
component->startDragging (component == this ? e : e.getEventRelativeTo (component));
}
}
DBG ("Note: " + String (note) + " " + String (beat) + " " + String (length));
}
else if (e.mods.isMiddleButtonDown())
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
PianoGridNote* component = dynamic_cast<PianoGridNote*>(selection.getSelectedItem (i));
if (component)
component->startVelocity (e);
}
}
}
void ListBox::startDragAndDrop (const MouseEvent& e, const var& dragDescription, bool allowDraggingToOtherWindows)
{
DragAndDropContainer* const dragContainer
= DragAndDropContainer::findParentDragContainerFor (this);
if (dragContainer != nullptr)
{
int x, y;
Image dragImage (createSnapshotOfSelectedRows (x, y));
MouseEvent e2 (e.getEventRelativeTo (this));
const Point<int> p (x - e2.x, y - e2.y);
dragContainer->startDragging (dragDescription, this, dragImage, allowDraggingToOtherWindows, &p);
}
else
{
// to be able to do a drag-and-drop operation, the listbox needs to
// be inside a component which is also a DragAndDropContainer.
jassertfalse;
}
}
void MenuBarComponent::mouseMove (const MouseEvent& e)
{
const MouseEvent e2 (e.getEventRelativeTo (this));
if (lastMousePos != e2.getPosition())
{
if (currentPopupIndex >= 0)
{
const int item = getItemAt (e2.getPosition());
if (item >= 0)
showMenu (item);
}
else
{
updateItemUnderMouse (e2.getPosition());
}
lastMousePos = e2.getPosition();
}
}
void GraphEditorPanel::endDraggingConnector (const MouseEvent& e)
{
if (draggingConnector == nullptr)
return;
draggingConnector->setTooltip (String::empty);
const MouseEvent e2 (e.getEventRelativeTo (this));
uint32 srcFilter = draggingConnector->sourceFilterID;
int srcChannel = draggingConnector->sourceFilterChannel;
uint32 dstFilter = draggingConnector->destFilterID;
int dstChannel = draggingConnector->destFilterChannel;
deleteAndZero (draggingConnector);
PinComponent* const pin = findPinAt (e2.x, e2.y);
if (pin != nullptr)
{
if (srcFilter == 0)
{
if (pin->isInput)
return;
srcFilter = pin->filterID;
srcChannel = pin->index;
}
else
{
if (! pin->isInput)
return;
dstFilter = pin->filterID;
dstChannel = pin->index;
}
graph.addConnection (srcFilter, srcChannel, dstFilter, dstChannel);
}
}
void MenuBarComponent::mouseMove (const MouseEvent& e)
{
const MouseEvent e2 (e.getEventRelativeTo (this));
if (lastMouseX != e2.x || lastMouseY != e2.y)
{
if (currentPopupIndex >= 0)
{
const int item = getItemAt (e2.x, e2.y);
if (item >= 0)
showMenu (item);
}
else
{
updateItemUnderMouse (e2.x, e2.y);
}
lastMouseX = e2.x;
lastMouseY = e2.y;
}
}
void PianoGridNote::mouseDrag (const MouseEvent& e)
{
if (! owner) return;
SelectedItemSet<MidiGridItem*> selection = owner->getLassoSelection ();
if (e.mods.isLeftButtonDown())
{
if (isResizing)
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
PianoGridNote* component = dynamic_cast<PianoGridNote*>(selection.getSelectedItem (i));
if (component)
component->continueResizing (e);
}
}
else if (isDragging)
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
MidiGridItem* component = selection.getSelectedItem (i);
component->continueDragging (component == this ? e : e.getEventRelativeTo (component));
}
}
}
else if (e.mods.isMiddleButtonDown())
{
if (isEditingVelocity)
{
for (int i = 0; i < selection.getNumSelected (); i++)
{
PianoGridNote* component = dynamic_cast<PianoGridNote*>(selection.getSelectedItem (i));
if (component)
component->continueVelocity (e);
}
}
}
}
void AutomationUI::mouseDrag(const MouseEvent & e)
{
if (e.originalComponent == this)
{
}else
{
AutomationKeyUI::Handle * h = dynamic_cast<AutomationKeyUI::Handle *>(e.eventComponent);
if (h != nullptr)
{
AutomationKeyUI * kui = static_cast<AutomationKeyUI *>(h->getParentComponent());
if (e.mods.isLeftButtonDown())
{
Point<int> mp = e.getEventRelativeTo(this).getPosition();
float pos = getPosForX(mp.x);
float val = (1 - mp.y*1.f / getHeight());
kui->item->position->setValue(pos);
kui->item->value->setValue(val);
}
}
}
}
void ComponentDragger::dragComponent (Component* const componentToDrag, const MouseEvent& e,
ComponentBoundsConstrainer* const constrainer)
{
jassert (componentToDrag != nullptr);
jassert (e.mods.isAnyMouseButtonDown()); // The event has to be a drag event!
if (componentToDrag != nullptr)
{
Rectangle<int> bounds (componentToDrag->getBounds());
// If the component is a window, multiple mouse events can get queued while it's in the same position,
// so their coordinates become wrong after the first one moves the window, so in that case, we'll use
// the current mouse position instead of the one that the event contains...
if (componentToDrag->isOnDesktop())
bounds += componentToDrag->getMouseXYRelative() - mouseDownWithinTarget;
else
bounds += e.getEventRelativeTo (componentToDrag).getPosition() - mouseDownWithinTarget;
if (constrainer != nullptr)
constrainer->setBoundsForComponent (componentToDrag, bounds, false, false, false, false);
else
componentToDrag->setBounds (bounds);
}
}
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;
}
}
}
