void AutoRiff::generate(){
clearComponents();
// fill the length of the riff
double curLengthInBeats = 0;
while(curLengthInBeats < lengthInBeats){
float genLengthInBeats = 0;
switch(sweet::NumberUtils::randomInt(0, 3)){
case 0: genLengthInBeats = 1; break;
case 1: genLengthInBeats = 0.5; break;
case 2: genLengthInBeats = 0.25; break;
case 3: genLengthInBeats = 0.125; break;
}
// generate a random number on the scale (will be used as an array accessor for AutoRiff::scales
int genPitch = sweet::NumberUtils::randomInt(generationMin, generationMax);
// make some notes rests instead of actual notes
float genVolume = (float)sweet::NumberUtils::randomInt(0, 1);
components.push_back(new Note(genLengthInBeats, genPitch, genVolume));
curLengthInBeats += components.back()->lengthInBeats;
}
if(curLengthInBeats > lengthInBeats){
components.back()->lengthInBeats -= curLengthInBeats - lengthInBeats;
}
AutoTrack::generate();
}
//----[ destroy ]------------------------------------------------------------
void EvidyonGUIModule_TradeDialog::destroy() {
hide();
quantity_prompt_.destroy();
clearComponents();
button_font_ = NULL;
trade_accepted_ = false;
}
void AutoRide::generate(){
clearComponents();
// generate ride hits
float beatUnit = 1.f/timeSignatureBottom;
unsigned long int numRide = 0;
switch(sweet::NumberUtils::randomInt(0,2)){
case 0: numRide = 1; break; // one primary per beat
case 1: numRide = 2; break; // two primary per beat
case 2: numRide = 4; break; // four primary per beat
}
for(unsigned long int i = 0; i < timeSignatureTop; ++i){
for(unsigned long int j = 0; j < numRide; ++j){
bool addSecondary = !sweet::NumberUtils::randomInt(0, 2);
if(addSecondary){
components.push_back(new Note(beatUnit/numRide*0.5f, 0, 0.5)); // primary hit
components.push_back(new Note(beatUnit/numRide*0.5f, 0, 0.25)); // secondary hit
}else{
components.push_back(new Note(beatUnit/numRide, 0, 0.5)); // primary hit
}
}
}
AutoTrack::generate();
}
//----[ destroy ]------------------------------------------------------------
void EvidyonGUIModule_Bazaar::destroy() {
hide();
inventory_.destroy();
items_in_category_.destroy();
create_listing_prompt_.destroy();
clearComponents();
}
void RemoveTrackModal::createTogglesFromExistingTracks(){
auto existingTracks = _timelineViewPtr->getExistingTracksRef();
clearComponents();
_tracksToggles.clear();
for (auto t : existingTracks){
auto label = t.name;
ofxDatGuiToggle* toggle = GuiFactory::createToggle(label, false, this, &RemoveTrackModal::onToggleEvent);
_tracksToggles.push_back(toggle);
addComponent(toggle);
}
}
//==============================================================================
void HostFilterComponent::changeListenerCallback (void* source)
{
if (source == this)
{
closePluginEditorWindows ();
}
else if (source == getFilter())
{
clearComponents ();
rebuildComponents ();
// reopen windows saved with session
Host* host = getFilter()->host;
for (int j = 0; j < host->getPluginsCount(); j++)
{
BasePlugin* plugin = host->getPluginByIndex (j);
if (plugin && plugin->getIntValue (PROP_WINDOWOPEN, 0))
openPluginEditorWindow (plugin);
}
resized ();
}
else if (source == getFilter()->getTransport())
{
// update transport !
CommandManager::getInstance()->commandStatusChanged ();
}
else if (source == &knownPluginList)
{
// save the plugin list every time it gets changed, so that if we're scanning
// and it crashes, we've still saved the previous ones
XmlElement* const savedPluginList = knownPluginList.createXml();
if (savedPluginList != 0)
{
ApplicationProperties::getInstance()->getUserSettings()
->setValue (T("pluginList"), savedPluginList);
delete savedPluginList;
ApplicationProperties::getInstance()->saveIfNeeded();
}
}
else
{
for (int i = pluginWindows.size(); --i >= 0;)
{
VstPluginWindow* window = pluginWindows.getUnchecked (i);
if (window)
window->updateParameters ();
}
}
}
void AutoSnare::generate(){
clearComponents();
// generate snare hits
float beatUnit = 1.f/timeSignatureBottom;
for(unsigned long int i = 0; i < timeSignatureTop; ++i){
int numSnare = 0;
switch(sweet::NumberUtils::randomInt(0,2)){
case 0: numSnare = 1; break;
case 1: numSnare = 2; break;
case 2: numSnare = 4; break;
}
float l = beatUnit/numSnare;
if(l < beatUnit && sweet::NumberUtils::randomBool()){
l = beatUnit-l;
}
bool addSecondary = sweet::NumberUtils::randomBool();
if(i % 2 == 1){
if(addSecondary){
components.push_back(new Note(l, 0, 1)); // primary hit
if(l < beatUnit){
components.push_back(new Note(beatUnit-l, 0, 0.5)); // secondary hit
}
}else{
components.push_back(new Note(beatUnit, 0, 1)); // primary hit for full beat
}
}else{
if(addSecondary){
components.push_back(new Note(beatUnit, 0, 0.5)); // secondary hit for full beat
}else{
// full rest
if(components.size() > 0){
components.back()->lengthInBeats += beatUnit;
}else{
components.push_back(new Note(beatUnit, 0, 0));
}
}
}
}
AutoTrack::generate();
}
//----[ sync ]---------------------------------------------------------------
void EvidyonGUIModuleActiveQuestDisplay::sync(const ActiveQuestData quest_data[3]) {
GUILayer* layer = hide();
clearComponents();
addComponent(&panel_);
for (int i = 0; i < 3; ++i) {
bool active = !quest_data[i].name.empty();
quests_active_[i] = active;
if (active) {
addComponent(&quest_buttons_[i]);
quest_buttons_[i].enable();
quest_names_[i] = quest_data[i].name;
quest_expiration_times_[i] = quest_data[i].expiration_time;
quest_indices_[i] = quest_data[i].quest_index;
}
}
show(layer);
}
void AutoDrums::generate(){
clearComponents();
unsigned long int numBeats = 1;
for(unsigned long int i = 0; i < numBeats; ++i){
AutoBeat * b = new AutoBeat(snare, kick, ride);
b->bpm = bpm;
b->timeSignatureTop = timeSignatureTop;
b->timeSignatureBottom = timeSignatureBottom;
std::cout << "Beat: " << bpm << "bpm, " << timeSignatureTop << "/" << timeSignatureBottom << std::endl;
b->generate();
components.push_back(b);
}
AutoTrack::generate();
lengthInBeats *= numBeats;
lengthInSeconds *= numBeats;
}
void AutoKick::generate(){
clearComponents();
// generate kick hits
float beatUnit = 1.f/timeSignatureBottom;
//kick->notes.push_back(Note(0.25, 0, 1)); // first primary hit always on 1
for(unsigned long int i = 0; i < timeSignatureTop; ++i){
int numKick;
switch(sweet::NumberUtils::randomInt(0,2)){
case 0: numKick = 1; break;
case 1: numKick = 2; break;
case 2: numKick = 4; break;
}
float l = beatUnit/numKick;
components.push_back(new Note(l, 0, 0.5));
if(l < beatUnit){
components.push_back(new Note(beatUnit-l, 0, 1));
}
}
AutoTrack::generate();
}
//----------------------------------------------------------------------------//
RenderedString::~RenderedString()
{
clearComponents();
}
AutoTrack::~AutoTrack(){
clearComponents();
}
MainTabbedComponent::~MainTabbedComponent ()
{
DBG ("MainTabbedComponent::~MainTabbedComponent");
clearComponents ();
}
Entity::~Entity()
{
clearComponents();
delete components;
}
//----[ destroy ]------------------------------------------------------------
void EvidyonGUIModuleActiveQuestDisplay::destroy() {
hide();
clearComponents();
}
ComponentContainer::~ComponentContainer()
{
clearComponents();
}
void EvidyonGUIModule_InventoryList::destroy() {
clearComponents();
button_font_ = NULL;
hide();
}
bool HostFilterComponent::perform (const InvocationInfo& info)
{
Config* config = Config::getInstance();
GraphComponent* graph = main->getGraph ();
Transport* transport = getFilter()->getTransport();
switch (info.commandID)
{
//----------------------------------------------------------------------------------------------
case CommandIDs::pluginOpen:
{
graph->loadAndAppendPlugin ();
break;
}
case CommandIDs::pluginClose:
{
graph->closeSelectedPlugins ();
break;
}
case CommandIDs::pluginClear:
{
graph->closeAllPlugins ();
break;
}
case CommandIDs::showPluginListEditor:
{
if (PluginListWindow::currentPluginListWindow == 0)
PluginListWindow::currentPluginListWindow = new PluginListWindow (knownPluginList);
PluginListWindow::currentPluginListWindow->toFront (true);
break;
}
//----------------------------------------------------------------------------------------------
#ifndef JOST_VST_PLUGIN
case CommandIDs::audioOptions:
{
StandaloneFilterWindow* window = findParentComponentOfClass ((StandaloneFilterWindow*) 0);
if (window)
window->showAudioSettingsDialog ();
break;
}
#endif
case CommandIDs::audioPlay:
{
transport->play ();
break;
}
case CommandIDs::audioPlayPause:
{
transport->togglePlay ();
break;
}
case CommandIDs::audioStop:
{
transport->stop ();
break;
}
case CommandIDs::audioRecord:
{
transport->record ();
break;
}
case CommandIDs::audioRewind:
{
transport->rewind ();
break;
}
case CommandIDs::audioLoop:
{
transport->setLooping (! transport->isLooping());
break;
}
//----------------------------------------------------------------------------------------------
case CommandIDs::sessionNew:
{
bool retValue =
AlertWindow::showYesNoCancelBox (AlertWindow::WarningIcon,
T("Unsaved Changes"),
T("Are you sure you want to close the current session? You may lose any unsaved changes."));
if (retValue)
{
closePluginEditorWindows ();
getFilter()->getHost ()->closeAllPlugins (true);
clearComponents ();
Config::getInstance()->lastSessionFile = File::nonexistent;
rebuildComponents ();
}
break;
}
case CommandIDs::sessionLoad:
{
FileChooser myChooser (T("Load a session file..."),
Config::getInstance ()->lastSessionDirectory,
JOST_SESSION_WILDCARD, JOST_USE_NATIVE_FILE_CHOOSER);
if (myChooser.browseForFileToOpen())
{
bool retValue =
AlertWindow::showYesNoCancelBox (AlertWindow::WarningIcon,
T("Unsaved Changes"),
T("Are you sure you want to close the current session? You may lose any unsaved changes."));
if (retValue)
{
MemoryBlock fileData;
File fileToLoad = myChooser.getResult();
if (fileToLoad.existsAsFile()
&& fileToLoad.loadFileAsData (fileData))
{
getFilter ()->setStateInformation (fileData.getData (), fileData.getSize());
Config::getInstance()->addRecentSession (fileToLoad);
Config::getInstance()->lastSessionFile = fileToLoad;
}
}
}
break;
}
case CommandIDs::sessionSave:
{
handleSaveCommand();
break;
}
case CommandIDs::sessionSaveNoPrompt:
{
handleSaveCommand(true);
break;
}
case CommandIDs::audioStemsStartStop:
{
getHost()->toggleStemRendering();
break;
}
case CommandIDs::audioStemsSetup:
{
FileChooser myChooser (T("Save Rendered Stem Files To..."),
Config::getInstance ()->lastStemsDirectory);
if (myChooser.browseForDirectory ())
{
Config::getInstance ()->lastStemsDirectory = myChooser.getResult();
}
break;
}
//----------------------------------------------------------------------------------------------
case CommandIDs::appToolbar:
{
toolbar->showCustomisationDialog (*factory,
Toolbar::allCustomisationOptionsEnabled);
// (Toolbar::allowIconsOnlyChoice | Toolbar::showResetToDefaultsButton));
break;
}
case CommandIDs::appBrowser:
{
setBrowserVisible (! config->showBrowser, config->browserLeft);
break;
}
case CommandIDs::appFullScreen:
{
DocumentWindow* window = findParentComponentOfClass <DocumentWindow> ();
if (window) {
window->setFullScreen (! window->isFullScreen ());
window->setMenuBar (window->isFullScreen () ? 0 : this);
}
break;
}
case CommandIDs::appExit:
{
deleteAndZero(PluginListWindow::currentPluginListWindow);
JUCEApplication::getInstance()->systemRequestedQuit();
break;
}
case CommandIDs::appAbout:
{
// Image* splashImage = ImageCache::getFromMemory (Resource::jost_about,
// Resource::jost_about_size);
// todo: move appResourcesFolder() to somewhere everyone can use it
#if JUCE_MAC
File appResourcesFolder(File::getSpecialLocation(File::currentApplicationFile).getChildFile("./Contents/Resources"));
#else
File appResourcesFolder(File::getSpecialLocation(File::currentApplicationFile).getParentDirectory());
#endif
File splashImageFile(appResourcesFolder.getChildFile("JiveAbout.png"));
Image* splashImage = ImageFileFormat::loadFrom(splashImageFile);
SplashScreen* splash = new SplashScreen();
splash->show (T(JucePlugin_Name), splashImage, 3500, false);
break;
}
//----------------------------------------------------------------------------------------------
default:
return false;
}
return true;
}
