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 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);
		}
	}
	
}

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 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();
}