GUI::MainComponent::~MainComponent ()
{
audioSourcePlayer.setSource (nullptr);
audioDeviceManager.removeAudioCallback (this);
removeChildComponent(manager);
removeChildComponent(rightPanel);
removeChildComponent(leftPanel);
removeChildComponent(topPanel);
removeChildComponent(centerPanel);
}
void EnvelopeComponent::removeHandle(EnvelopeHandleComponent* thisHandle)
{
if(handles.size() > minNumHandles) {
int index = handles.indexOf(thisHandle);
if(releaseNode >= 0)
{
if(releaseNode == index)
releaseNode = -1;
else if(releaseNode > index)
releaseNode--;
}
if(loopNode >= 0)
{
if(loopNode == index)
loopNode = -1;
else if(loopNode > index)
loopNode--;
}
handles.removeFirstMatchingValue(thisHandle);
removeChildComponent(thisHandle);
delete thisHandle;
sendChangeMessage();
repaint();
}
}
ComponentLayoutEditor::~ComponentLayoutEditor()
{
document.removeChangeListener (this);
removeChildComponent (&lassoComp);
deleteAllChildren();
}
void TabbedComponent::changeCallback (const int newCurrentTabIndex, const String& newTabName)
{
if (panelComponent != nullptr)
{
panelComponent->setVisible (false);
removeChildComponent (panelComponent);
panelComponent = nullptr;
}
if (getCurrentTabIndex() >= 0)
{
panelComponent = getTabContentComponent (getCurrentTabIndex());
if (panelComponent != nullptr)
{
// do these ops as two stages instead of addAndMakeVisible() so that the
// component has always got a parent when it gets the visibilityChanged() callback
addChildComponent (panelComponent);
panelComponent->setVisible (true);
panelComponent->toFront (true);
}
repaint();
}
resized();
currentTabChanged (newCurrentTabIndex, newTabName);
}
//==================================================================================================================
void ComponentLayoutEditor::mouseUp (const MouseEvent& e)
{
updateSelectedComponentBounds();
lassoComp.endLasso();
removeChildComponent (&lassoComp);
}
GUI::ClientListComponent::~ClientListComponent()
{
removeChildComponent(clientListBox);
rightsImageButton->removeListener(this);
showImageButton->removeListener(this);
writeClientDetailsToXML();
}
void AutomationUI::inspectablesSelectionChanged()
{
if (transformer != nullptr)
{
removeChildComponent(transformer);
transformer = nullptr;
}
Array<AutomationKeyUI *> uiSelection;
if (manager->selectionManager->currentInspectables.size() >= 2)
{
}
for (auto &i : manager->selectionManager->currentInspectables)
{
AutomationKey * k = static_cast<AutomationKey *>(i);
if (k == nullptr) continue;
AutomationKeyUI * kui = getUIForItem(k);
if (kui == nullptr) return;
uiSelection.add(kui);
}
if (uiSelection.size() >= 2)
{
transformer = new AutomationMultiKeyTransformer(this, uiSelection);
addAndMakeVisible(transformer);
}
}
void MainContentComponent::buttonClicked (Button *button) {
if (button == &startButton) {
removeChildComponent(&startButton);
// String myString = (chooseMidi->getSelectedFile(1)).getFullPathName();
// std::cout<<myString<<std::endl;
// myObstacle = new ObstacleComponent((myString.toStdString()).c_str());
// ypos = myObstacle->getInitialHeight()-35;
processingAudio = new AudioProcess(myObstacle->getStartNote()+12);
deviceManager.initialise( 1, 2, 0, true, String::empty, 0 );
deviceManager.addAudioCallback(processingAudio);
gameStart();
}
if (button == &stopButton) {
gameOver();
}
if (button == &restartButton) {
removeAllChildren();
stopTimer();
reset();
gameStart();
}
}
PaintRoutineEditor::~PaintRoutineEditor()
{
document.removeChangeListener (this);
removeAllElementComps();
removeChildComponent (&lassoComp);
deleteAllChildren();
}
void MainContentComponent::newLife() {
newlifeTime = processingAudio->getTimeElapsed();
if (lifeIdx>=0 && lifeIdx<4){
removeChildComponent(livesLeft.getUnchecked(lifeIdx++));
Copter = livesLeft.getUnchecked(lifeIdx);
}
}
void SlidingStackComponent::handleContentComponentRemoved (Component* contentRemoved, int index, bool animate)
{
if (animate)
{
Desktop::getInstance().getAnimator().fadeOut (contentRemoved, 200);
removeChildComponent (contentRemoved);
if (shouldContentComponentBeDeleted(contentRemoved))
delete contentRemoved;
}
else
{
removeChildComponent (contentRemoved);
if (shouldContentComponentBeDeleted(contentRemoved))
delete contentRemoved;
}
}
void MainContentComponent::collisionDetection() {
if ( obsX < (0.15*winWidth + 80) ) {
if ( ( curObsPos + 50 < ypos || (curObsPos -50) > ypos ) && curObsPos > 0 ){ //Within one semitone difference
addAndMakeVisible(hitLabel);
copterHits++;
hitsDisplay = "Number of hits: ";
hitsDisplay += copterHits;
numHitsLabel.setText(hitsDisplay, dontSendNotification);
}
else if( curObsPos != -1 ){
removeChildComponent(&hitLabel);
}
}
if(copterHits > 50) {
gameOver();
}
if( copterHits%10 == 0 && copterHits > 0 && (processingAudio->getTimeElapsed() - newlifeTime) > 1.0f){
newLife();
}
}
void AutomationUI::mouseDown(const MouseEvent & e)
{
BaseManagerUI::mouseDown(e);
if (e.eventComponent == this)
{
if (e.mods.isLeftButtonDown() && e.mods.isCtrlDown())
{
manager->addItem(getPosForX(e.getPosition().x), (1 - e.getPosition().y*1.f / getHeight()));
}else
{
Array<Component *> selectables;
Array<Inspectable *> inspectables;
for (auto &i : itemsUI) if (i->isVisible())
{
selectables.add(&i->handle);
inspectables.add(i->inspectable);
}
if (transformer != nullptr)
{
removeChildComponent(transformer);
transformer = nullptr;
}
if(InspectableSelector::getInstance()) InspectableSelector::getInstance()->startSelection(this, selectables, inspectables,manager->selectionManager);
}
}
}
void ComponentLayoutEditor::mouseUp (const MouseEvent& e)
{
lassoComp.endLasso();
removeChildComponent (&lassoComp);
if (e.mouseWasClicked() && ! e.mods.isAnyModifierKeyDown())
layout.getSelectedSet().deselectAll();
}
ConditionList::~ConditionList()
{
for (int i = 0; i < conditionButtons.size(); i++)
{
removeChildComponent(conditionButtons[i]);
}
}
void ZoomingShiftingComponent::deleteAllZoomedComps() {
// Bouml preserved body begin 0003D88D
for (int i = 0 ; i < zoomedComponents.size() ; i++)
{
removeChildComponent(zoomedComponents[i]);
}
zoomedComponents.clear(true);
// Bouml preserved body end 0003D88D
}
FileBrowserComponent::~FileBrowserComponent()
{
if (previewComp != 0)
removeChildComponent (previewComp);
deleteAllChildren();
fileList = 0;
thread.stopThread (10000);
}
void StackComponent::handleContentComponentRemoved (Component* contentRemoved, int index, bool animate)
{
removeChildComponent (contentRemoved);
if (shouldContentComponentBeDeleted(contentRemoved))
{
DBG ("deleting component " << contentRemoved->getName());
delete contentRemoved;
}
}
ProjectContentComponent::~ProjectContentComponent()
{
IntrojucerApp::getApp().openDocumentManager.removeListener (this);
logo = nullptr;
setProject (nullptr);
contentView = nullptr;
removeChildComponent (&bubbleMessage);
jassert (getNumChildComponents() <= 1);
}
void AutomationUI::removeItemUIInternal(AutomationKeyUI * kui)
{
if (transformer != nullptr)
{
removeChildComponent(transformer);
transformer = nullptr;
}
kui->handle.removeMouseListener(this);
updateROI();
}
void Toolbar::itemDragExit (const SourceDetails& dragSourceDetails)
{
ToolbarItemComponent* const tc = dynamic_cast <ToolbarItemComponent*> (dragSourceDetails.sourceComponent.get());
if (tc != nullptr && isParentOf (tc))
{
items.removeObject (tc, false);
removeChildComponent (tc);
updateAllItemPositions (true);
}
}
SpikeDetectorEditor::~SpikeDetectorEditor()
{
for (int i = 0; i < electrodeButtons.size(); i++)
{
removeChildComponent(electrodeButtons[i]);
}
deleteAllChildren();
}
void Grid::showPageAtIndex(int idx) {
removeChildComponent(page);
page->setEnabled(false);
page->setVisible(false);
page = pages[idx];
addAndMakeVisible(page);
page->setVisible(true);
page->setEnabled(true);
resized();
}
//==============================================================================
void ResizableWindow::clearContentComponent()
{
if (ownsContentComponent)
{
contentComponent.deleteAndZero();
}
else
{
removeChildComponent (contentComponent);
contentComponent = nullptr;
}
}
void PdAudioProcessorEditor::rebuildGUIParams(PureDataAudioProcessor * p){
for(auto & c:juce_Components){
removeChildComponent(c);
}
juce_Components.clear();
int idx = 0;
Rectangle<int> area = p->patchRect;
for(auto & param:p->pulpParameterDescs){
LabelComponent *c=nullptr;
if(param.type == PdParamGetter::PulpParameterDesc::KNOB || param.type == PdParamGetter::PulpParameterDesc::NUMBOX){
c =new SendSlider(idx,*p);
((SendSlider*)c)->setRange(param.min, param.max);
}
else if(param.type == PdParamGetter::PulpParameterDesc::TOGGLE){
c =new SendToggle(idx,*p);
}
if(c!=nullptr){
c->labelSize = param.labelSize;
c->setName(param.labelName);
p->setParameterName(idx, param.name);
juce_Components.add(c);
c->setBounds (
area.getX() + area.getWidth() * param.getX(),
area.getY() + area.getHeight()* param.getY(),
area.getWidth() * param.getWidth() ,
area.getHeight()* param.getHeight()
);
idx++;
}
else{
DBG( "no viable parameters for "<<param.name);;;
}
}
for(auto & c:juce_Components){
addAndMakeVisible(c);
}
}
void ScreenDisplay::setScreen (const int i)
{
if (currentScreen)
removeChildComponent (currentScreen);
this->currentScreen = screens->getScreen (*this, (int) i);
if (currentScreen) {
addAndMakeVisible (currentScreen);
}
resized();
}
//==============================================================================
void TabbedButtonBar::clearTabs()
{
tabs.clear();
tabColours.clear();
currentTabIndex = -1;
deleteAndZero (extraTabsButton);
removeChildComponent (behindFrontTab);
deleteAllChildren();
addChildComponent (behindFrontTab);
setCurrentTabIndex (-1);
}
void PMixInterpolationSpaceLayout::updateComponents()
{
// for (int i = getNumChildComponents(); --i >= 0;)
// {
// if (InterpolationSpacePreset* const pc = dynamic_cast <InterpolationSpacePreset*> (getChildComponent (i)))
// pc->update();
// }
for (int i = audioEngine.getDoc().getNumNodes(); --i >= 0;)
{
const AudioProcessorGraph::Node::Ptr f (audioEngine.getDoc().getNode (i));
if (!InternalPluginFormat::isInternalFormat(f->getProcessor()->getName()))
{
Array<InterpolationSpacePreset*> comps;
getComponentsForNode(f->nodeID, comps);
Array<var>* presets = f->properties.getVarPointer("presets")->getArray();
// if the number of presets for this node has changed then delete the components and re-create
if (comps.size() != presets->size())
{
for (int componentIdx = 0; componentIdx<comps.size(); componentIdx++)
{
removeChildComponent(comps[componentIdx]);
delete comps[componentIdx];
}
for (int presetIdx = 0; presetIdx < presets->size(); presetIdx++)
{
DynamicObject* obj = presets->getReference(presetIdx).getDynamicObject();
String label = obj->getProperty("name");
InterpolationSpacePreset* const comp = new InterpolationSpacePreset(audioEngine, label, f->nodeID, obj->getProperty("uid"), audioEngine.getDoc().getNodeColour(f->nodeID) );
String componentID;
componentID << "p." << (int) f->nodeID << "." << presetIdx;
comp->setComponentID(componentID);
float r = MIN_RADIUS + (RADIUS_RANGE * (float) obj->getProperty("radius"));
float x = getWidth() * (float) obj->getProperty("x");
float y = getHeight() * (float) obj->getProperty("y");
comp->setSize(r, r);
comp->setCentrePosition(x, y);
comp->update();
addAndMakeVisible (comp);
}
}
}
}
}
void setDemo (GraphicsDemoBase* newDemo)
{
if (currentDemo != nullptr)
removeChildComponent (currentDemo);
currentDemo = newDemo;
if (currentDemo != nullptr)
{
addAndMakeVisible (currentDemo);
startTimerHz (60);
resized();
}
}
void MainContentComponent::gamePlayEvents() {
if ( roundf( processingAudio->getTimeElapsed() - gameStartTime ) == 5 ) {
removeChildComponent(&gameLogo);
}
if ( roundf( processingAudio->getTimeElapsed() - gameStartTime ) == 4 ) {
processingAudio->setNotePlay(false);
}
if ( roundf( processingAudio->getTimeElapsed() - gameStartTime )
== roundf(myObstacle->getEndTime() + 5) ) { //5 seconds overhead in scrolling
gameOver();
}
}
