void ProjectTreeViewBase::moveItems (OwnedArray <Project::Item>& selectedNodes, Project::Item destNode, int insertIndex) { for (int i = selectedNodes.size(); --i >= 0;) { Project::Item* const n = selectedNodes.getUnchecked(i); if (destNode == *n || destNode.state.isAChildOf (n->state)) // Check for recursion. return; if (! destNode.canContain (*n)) selectedNodes.remove (i); } // Don't include any nodes that are children of other selected nodes.. for (int i = selectedNodes.size(); --i >= 0;) { Project::Item* const n = selectedNodes.getUnchecked(i); for (int j = selectedNodes.size(); --j >= 0;) { if (j != i && n->state.isAChildOf (selectedNodes.getUnchecked(j)->state)) { selectedNodes.remove (i); break; } } } // Remove and re-insert them one at a time.. for (int i = 0; i < selectedNodes.size(); ++i) { Project::Item* selectedNode = selectedNodes.getUnchecked(i); if (selectedNode->state.getParent() == destNode.state && indexOfNode (destNode.state, selectedNode->state) < insertIndex) --insertIndex; selectedNode->removeItemFromProject(); destNode.addChild (*selectedNode, insertIndex++); } }
RowItem* findItem (const int uid) const throw() { for (int i = items.size(); --i >= 0;) { RowItem* const ri = items.getUnchecked(i); if (ri->uid == uid) return ri; } return 0; }
//============================================================================== void DefaultMenuBarItemHandler::setupDefaultItemsIfNecessary() { if (menuBarItems.size() <= 0) { menuBarItems.add (new FileMenuBarItem()); menuBarItems.add (new EditMenuBarItem()); menuBarItems.add (new ViewMenuBarItem()); menuBarItems.add (new BuildMenuBarItem()); menuBarItems.add (new ToolsMenuBarItem()); menuBarItems.add (new HelpMenuBarItem()); } }
Trail* getTrail (const MouseInputSource& source) { for (int i = 0; i < trails.size(); ++i) { Trail* t = trails.getUnchecked(i); if (t->source == source) return t; } return nullptr; }
void ComponentLayoutEditor::itemDropped (const SourceDetails& dragSourceDetails) { OwnedArray <Project::Item> selectedNodes; ProjectContentComponent::getSelectedProjectItemsBeingDragged (dragSourceDetails, selectedNodes); StringArray filenames; for (int i = 0; i < selectedNodes.size(); ++i) if (selectedNodes.getUnchecked(i)->getFile().hasFileExtension (".cpp")) filenames.add (selectedNodes.getUnchecked(i)->getFile().getFullPathName()); filesDropped (filenames, dragSourceDetails.localPosition.x, dragSourceDetails.localPosition.y); }
static bool isAnyModuleNewerThanProjucer (const OwnedArray<ModuleDescription>& modules) { for (int i = modules.size(); --i >= 0;) { const ModuleDescription* m = modules.getUnchecked(i); if (m->getID().startsWith ("juce_") && getJuceVersion (m->getVersion()) > getBuiltJuceVersion()) return true; } return false; }
void ColumnFileBrowserContents::resized() { int width = 0; const int height = getHeight(); for (int i = 0; i < columns.size(); i++) { columns[i]->setBounds (width, 0, columns[i]->getWidth(), height); width += columns[i]->getWidth(); } setSize (width, height); }
void buttonClicked (Button* button) override { if (button == &nativeButton) { getLookAndFeel().setUsingNativeAlertWindows (nativeButton.getToggleState()); return; } for (int i = windowButtons.size(); --i >= 0;) if (button == windowButtons.getUnchecked (i)) return showWindow (*button, static_cast<DialogType> (i)); }
void Ebu128LoudnessMeter::reset() { // the bins for (int k=0; k != bin.size(); ++k) { OwnedArray<double>* binsForTheKthChannel = bin[k]; for (int i=0; i != binsForTheKthChannel->size(); ++i) { double* ithBin = binsForTheKthChannel->getUnchecked(i); *ithBin = 0.0; } } // momentary and short term loudness. for (int k = 0; k != momentaryLoudness.size(); ++k) { momentaryLoudness.set(k, var(minimalReturnValue)); shortTermLoudness.set(k, minimalReturnValue); } // To ensure the returned momentary and short term loudness are at its // minimum, even if no audio is processed at the moment. for (int k = 0; k < averageOfTheLast400ms.size(); ++k) { *averageOfTheLast400ms[k] = 0.0; } for (int k = 0; k < averageOfTheLast3s.size(); ++k) { *averageOfTheLast3s[k] = 0.0; } // integrated loudness numberOfBlocksToCalculateRelativeThreshold = 0; sumOfAllBlocksToCalculateRelativeThreshold = 0.0; relativeThreshold = absoluteThreshold; histogramOfBlockLoudness.clear(); integratedLoudness = minimalReturnValue; // Loudness range numberOfBlocksToCalculateRelativeThresholdLRA = 0; sumOfAllBlocksToCalculateRelativeThresholdLRA = 0.0; relativeThresholdLRA = absoluteThreshold; histogramOfBlockLoudnessLRA.clear(); loudnessRangeStart = minimalReturnValue; loudnessRangeEnd = minimalReturnValue; }
//============================================================================== //============================================================================== void NonMember::printSlidersParams(const PluginProcessor& processor, const OwnedArray<Slider>& sliders) { String message; for (int i = 0; i < processor.numParams(); ++i) { jassert (i < sliders.size()); jassert (sliders[i]); message << "Sliders["<<i<<"] " << sliders[i]->getValue() << " params["<<i<<"] " << processor.getParam(i).get() << "\n"; } Logger::outputDebugString (message); }
bool SmugMug::deleteDuplicates(SmugID albumId) { OwnedArray<ImageItem> images; if (getImages(images, albumId)) { OwnedArray<SmugID> duplicateIds; StringArray fileNames; for (int i = 0; i < images.size(); i++) { if (fileNames.contains(images[i]->filename)) duplicateIds.add(new SmugID(images[i]->id)); else fileNames.add(images[i]->filename); } for (int i = 0; i < duplicateIds.size(); i++) deleteImage(*duplicateIds[i]); return true; } return false; }
static void initJuceDevicesIfNeeded() { static AudioDeviceManager sDeviceManager; if (gDeviceTypes.size() != 0) return; sDeviceManager.createAudioDeviceTypes(gDeviceTypes); CARLA_SAFE_ASSERT_RETURN(gDeviceTypes.size() != 0,); new JuceCleanup(); // remove JACK from device list for (int i=0, count=gDeviceTypes.size(); i < count; ++i) { if (gDeviceTypes[i]->getTypeName() == "JACK") { gDeviceTypes.remove(i, true); break; } } }
void ColumnFileBrowserContents::selectedFileChanged (const File& file) { // if last column clicked add new column if (columns[activeColumn] == columns.getLast()) { addColumn (file); } else // otherwise remove uneeded columns and change last { for (int i = 0; i < columns.size(); i++) { if (columns[activeColumn] == columns[i]) { const int numColumnsToRemove = columns.size() - i - (file.isDirectory() ? 1 : 0); removeColumn (numColumnsToRemove); if (file.isDirectory()) columns.getLast()->setRoot (file); break; } } resized(); } // stick to edges of viewport if (getWidth() < viewport->getWidth()) { viewport->setViewPosition (0, 0); } else if (file.exists() || (getRight() < viewport->getRight())) { const int ammountToSubtract = viewport->getRight() - getRight(); viewport->setViewPosition (viewport->getViewPositionX() - ammountToSubtract, 0); } }
void reorderChildren (const OwnedArray<ValueTree>& newOrder, UndoManager* undoManager) { jassert (newOrder.size() == children.size()); for (int i = 0; i < children.size(); ++i) { SharedObject* const child = newOrder.getUnchecked(i)->object; if (children.getObjectPointerUnchecked (i) != child) { const int oldIndex = children.indexOf (child); jassert (oldIndex >= 0); moveChild (oldIndex, i, undoManager); } } }
void ProjectTreeViewBase::itemDropped (const DragAndDropTarget::SourceDetails& dragSourceDetails, int insertIndex) { OwnedArray <Project::Item> selectedNodes; getAllSelectedNodesInTree (dragSourceDetails.sourceComponent, selectedNodes); if (selectedNodes.size() > 0) { TreeView* tree = getOwnerView(); ScopedPointer <XmlElement> oldOpenness (tree->getOpennessState (false)); moveSelectedItemsTo (selectedNodes, insertIndex); if (oldOpenness != nullptr) tree->restoreOpennessState (*oldOpenness, false); } }
//============================================================================== void AudioDeviceManager::createDeviceTypesIfNeeded() { if (availableDeviceTypes.size() == 0) { OwnedArray <AudioIODeviceType> types; createAudioDeviceTypes (types); for (int i = 0; i < types.size(); ++i) addAudioDeviceType (types.getUnchecked(i)); types.clear (false); if (AudioIODeviceType* first = availableDeviceTypes.getFirst()) currentDeviceType = first->getTypeName(); } }
void MixerAudioSource::removeAllInputs() { OwnedArray<AudioSource> toDelete; { const ScopedLock sl (lock); for (int i = inputs.size(); --i >= 0;) if (inputsToDelete[i]) toDelete.add (inputs.getUnchecked(i)); inputs.clear(); } for (int i = toDelete.size(); --i >= 0;) toDelete.getUnchecked(i)->releaseResources(); }
void run() { OwnedArray<ImageItem> images; bool res = smugmug->getImages(images, ur->getAlbumId()); smugmug->lock.enter(); if (res) { for (int i = ur->getNumImages() - 1; i >= 0; i--) { for (int j = 0; j < images.size(); j++) { if (ur->getImageFile(i).getFileName() == images[j]->filename) { ur->getImageFileInfo(i).status = UploadFile::Duplicate; } } } } for (int i = 0; i < smugmug->uploadQueue.size(); i++) { if (smugmug->uploadQueue[i]->getAlbumId().id == ur->getAlbumId().id) { for (int j = 0; j < smugmug->uploadQueue[i]->getNumImages(); j++) { for (int k = 0; k < ur->getNumImages(); k++) { if (ur->getImageFile(k).getFileName() == smugmug->uploadQueue[i]->getImageFile(j).getFileName()) { ur->getImageFileInfo(k).status = UploadFile::Duplicate; } } } } } smugmug->lock.exit(); smugmug->uploadImages(ur, false); smugmug->lock.enter(); smugmug->dupeThreads.removeFirstMatchingValue(this); smugmug->lock.exit(); triggerAsyncUpdate(); }
const KnownTypeface* matchTypeface (const String& familyName, const String& style) const noexcept { std::clog << "matchTypeface: " << familyName << " " << style << std::endl; for (int i = 0; i < faces.size(); ++i) { const KnownTypeface* const face = faces.getUnchecked(i); std::clog << " matchTypeface: " << face->family << " " << face->style << std::endl; if ((face->family == familyName || familyName.isEmpty()) && (face->style.equalsIgnoreCase (style) || style.isEmpty())) return face; } std::cout << "NO MATCHING FONT FOUND" << std::endl; return nullptr; }
static void replaceTabsWithSpaces (OwnedArray <SyntaxToken>& tokens, const int spacesPerTab) throw() { int x = 0; for (int i = 0; i < tokens.size(); ++i) { SyntaxToken* const t = tokens.getUnchecked(i); for (;;) { int tabPos = t->text.indexOfChar (T('\t')); if (tabPos < 0) break; const int spacesNeeded = spacesPerTab - ((tabPos + x) % spacesPerTab); t->text = t->text.replaceSection (tabPos, 1, String::repeatedString (T(" "), spacesNeeded)); } x += t->text.length(); } }
static void initJuceDevicesIfNeeded() { static AudioDeviceManager sDeviceManager; static bool needsInit = true; if (! needsInit) return; needsInit = false; new JuceCleanup(); sDeviceManager.createAudioDeviceTypes(gDeviceTypes); // remove JACK from device list for (int i=0, count=gDeviceTypes.size(); i < count; ++i) { if (gDeviceTypes[i]->getTypeName() == "JACK") { gDeviceTypes.remove(i, true); break; } } }
void MainHostWindow::filesDropped (const StringArray& files, int x, int y) { GraphDocumentComponent* const graphEditor = getGraphEditor(); if (graphEditor != nullptr) { if (files.size() == 1 && File (files[0]).hasFileExtension (filenameSuffix)) { if (graphEditor->graph.saveIfNeededAndUserAgrees() == FileBasedDocument::savedOk) graphEditor->graph.loadFrom (File (files[0]), true); } else { OwnedArray <PluginDescription> typesFound; knownPluginList.scanAndAddDragAndDroppedFiles (formatManager, files, typesFound); Point<int> pos (graphEditor->getLocalPoint (this, Point<int> (x, y))); for (int i = 0; i < jmin (5, typesFound.size()); ++i) createPlugin (typesFound.getUnchecked(i), pos.getX(), pos.getY()); } } }
bool BufferingAudioReader::readNextBufferChunk() { const int64 pos = nextReadPosition; const int64 startPos = ((pos - 1024) / samplesPerBlock) * samplesPerBlock; const int64 endPos = startPos + numBlocks * samplesPerBlock; OwnedArray<BufferedBlock> newBlocks; for (int i = blocks.size(); --i >= 0;) if (blocks.getUnchecked(i)->range.intersects (Range<int64> (startPos, endPos))) newBlocks.add (blocks.getUnchecked(i)); if (newBlocks.size() == numBlocks) { newBlocks.clear (false); return false; } for (int64 p = startPos; p < endPos; p += samplesPerBlock) { if (getBlockContaining (p) == nullptr) { newBlocks.add (new BufferedBlock (*source, p, samplesPerBlock)); break; // just do one block } } { const ScopedLock sl (lock); newBlocks.swapWith (blocks); } for (int i = blocks.size(); --i >= 0;) newBlocks.removeObject (blocks.getUnchecked(i), false); return true; }
bool EffectDataEntry::EffDatEntryLoad (ShowFile& show, uint32 version, const OwnedArray<Device>& devices, const OwnedArray<EffectPattern>& patterns) { // each effect data has a pointer to a position control. The // position control belongs to a device. Therefor we saved the // device index and the control index which identifies the // position control. We will load both those indices and // validate them and find the correlating positon control int deviceIndex = 0; int controlIndex = 0; // load the device index if (! show.readInt (deviceIndex)) return false; // load control index if (! show.readInt (controlIndex)) return false; // get device count int deviceCount = devices.size(); // validate the device index if (( deviceIndex < 0 ) || ( deviceIndex >= deviceCount)) return false; // get the device pointer from the device manager Device* pDevice = devices[deviceIndex]; // get the control count int controlCount = pDevice->DeviceGetControlCount(); // validate the control index if (( controlIndex < 0 ) || ( controlIndex >= controlCount)) return false; // get the control pointer from the device and assign it to our member m_pControl = pDevice->DeviceGetControl (controlIndex); // double check that it is a position control if (m_pControl->ControlGetType() != CT_POSITION) return false; // create empty effect data object ScopedPointer<EffectData>pEffectData = new EffectData; if (! pEffectData ) return false; // load the effect data if (! pEffectData->EffectDataLoad (show, version, patterns)) return false; // assign the new effect data to our member m_pEffectData = pEffectData; pEffectData.release(); return true; }
bool refillCache (const int numSamples, double startTime, const double endTime, const double rate, const int numChans, const int sampsPerThumbSample, LevelDataSource* levelData, const OwnedArray<ThumbData>& chans) { const double timePerPixel = (endTime - startTime) / numSamples; if (numSamples <= 0 || timePerPixel <= 0.0 || rate <= 0) { invalidate(); return false; } if (numSamples == numSamplesCached && numChannelsCached == numChans && startTime == cachedStart && timePerPixel == cachedTimePerPixel && ! cacheNeedsRefilling) { return ! cacheNeedsRefilling; } numSamplesCached = numSamples; numChannelsCached = numChans; cachedStart = startTime; cachedTimePerPixel = timePerPixel; cacheNeedsRefilling = false; ensureSize (numSamples); if (timePerPixel * rate <= sampsPerThumbSample && levelData != nullptr) { int sample = roundToInt (startTime * rate); Array<float> levels; int i; for (i = 0; i < numSamples; ++i) { const int nextSample = roundToInt ((startTime + timePerPixel) * rate); if (sample >= 0) { if (sample >= levelData->lengthInSamples) break; levelData->getLevels (sample, jmax (1, nextSample - sample), levels); const int totalChans = jmin (levels.size() / 2, numChannelsCached); for (int chan = 0; chan < totalChans; ++chan) getData (chan, i)->setFloat (levels.getUnchecked (chan * 2), levels.getUnchecked (chan * 2 + 1)); } startTime += timePerPixel; sample = nextSample; } numSamplesCached = i; } else { jassert (chans.size() == numChannelsCached); for (int channelNum = 0; channelNum < numChannelsCached; ++channelNum) { ThumbData* channelData = chans.getUnchecked (channelNum); MinMaxValue* cacheData = getData (channelNum, 0); const double timeToThumbSampleFactor = rate / (double) sampsPerThumbSample; startTime = cachedStart; int sample = roundToInt (startTime * timeToThumbSampleFactor); for (int i = numSamples; --i >= 0;) { const int nextSample = roundToInt ((startTime + timePerPixel) * timeToThumbSampleFactor); channelData->getMinMax (sample, nextSample, *cacheData); ++cacheData; startTime += timePerPixel; sample = nextSample; } } } return true; }
const String SAMCompiler::compile(ValueTree mdlRoot_) { String dspContent; //========================================================================== // DSP file header //========================================================================== dspContent << "// This DSP file has been generated by the Synth-A-Modeler compiler.\n"; dspContent << "import(\"physicalmodeling.lib\");\n\n"; //========================================================================== ValueTree faustTree = mdlRoot_.getChildWithName(Objects::variables); ValueTree massTree = mdlRoot_.getChildWithName(Objects::masses); ValueTree linkTree = mdlRoot_.getChildWithName(Objects::links); ValueTree wgTree = mdlRoot_.getChildWithName(Objects::waveguides); ValueTree jTree = mdlRoot_.getChildWithName(Objects::junctions); ValueTree tTree = mdlRoot_.getChildWithName(Objects::terminations); ValueTree aoTree = mdlRoot_.getChildWithName(Objects::audioobjects); int numMasslike = 0; int numPorts = 0; int numWaveguides = 0; int numJunctions = 0; String wgTermString; String junctString; StringArray wgOutputs; StringArray wgInputs; StringArray massWithJunct; StringArray linkWithJunct; StringArray massWithJunctLine; StringArray portWithJunctLine; StringArray massWithJunctOutputs; StringArray junctInputs; StringArray junctOutputs; //========================================================================== //========================================================================== // Write all waveguides and terminations //========================================================================== OwnedArray<WgWithSuffixes> wgWithSuffixes; for (int i = 0; i < wgTree.getNumChildren(); ++i) { ++numWaveguides; ValueTree wg = wgTree.getChild(i); WgWithSuffixes* wws = new WgWithSuffixes(); wws->wgId = wg[Ids::identifier].toString(); ValueTree left = jTree.getChildWithProperty(Ids::identifier, wg[Ids::startVertex]); ValueTree right; if (left.isValid()) { right = tTree.getChildWithProperty(Ids::identifier, wg[Ids::endVertex]); } else { left = tTree.getChildWithProperty(Ids::identifier, wg[Ids::startVertex]); right = jTree.getChildWithProperty(Ids::identifier, wg[Ids::endVertex]); } ValueTree term; ValueTree junct; StringArray wgSuffixes; if (left.getType() == Ids::termination) { wgSuffixes.add(wgR); wgSuffixes.add(wgL); wgSuffixes.add(wgRp); wgSuffixes.add(wgLp); term = left; junct = right; wws->termRight = false; } else if (left.getType() == Ids::junction) { wgSuffixes.add(wgL); wgSuffixes.add(wgR); wgSuffixes.add(wgLp); wgSuffixes.add(wgRp); term = right; junct = left; wws->termRight = true; } wws->wgSuffixes = wgSuffixes; wgInputs.add(wg[Ids::identifier].toString() + wgLp); wgInputs.add(wg[Ids::identifier].toString() + wgRp); wgOutputs.add(wg[Ids::identifier].toString() + wgL); wgOutputs.add(wg[Ids::identifier].toString() + wgR); ValueTree paWg = wg.getChildWithName(Ids::parameters); StringArray paWgStrings; for (int j = 0; j < paWg.getNumChildren(); ++j) { paWgStrings.add(paWg.getChild(j)[Ids::value].toString()); } wws->wgParams = paWgStrings; wgWithSuffixes.add(wws); ValueTree paTerm = term.getChildWithName(Ids::parameters); StringArray paTermStrings; for (int j = 0; j < paTerm.getNumChildren(); ++j) { paTermStrings.add(paTerm.getChild(j)[Ids::value].toString()); } //====================================================================== wgTermString << "\t"; wgTermString << wg[Ids::identifier].toString(); wgTermString << wgSuffixes[0] << " = " << term[Ids::identifier].toString(); wgTermString << " : "; wgTermString << paWgStrings[1]; wgTermString << ";\n\t"; wgTermString << term[Ids::identifier].toString(); wgTermString << " = "; wgTermString << wg[Ids::identifier].toString() << wgSuffixes[3]; wgTermString << " : "; wgTermString << paTermStrings[0] << ";\n\n"; //====================================================================== } //========================================================================== // Write all junctions //========================================================================== for (int i = 0; i < jTree.getNumChildren(); ++i) { ++numJunctions; ValueTree junct = jTree.getChild(i); junctOutputs.add(junct[Ids::identifier].toString()); junctInputs.add(junct[Ids::identifier].toString()+"p"); ValueTree wgs = getWgForJunct(wgTree, junct); StringArray junctWgOuts; StringArray junctWgParams; junctString << "\t"; for (int k = 0; k < wgs.getNumChildren(); ++k) { ValueTree wg = wgs.getChild(k); int wgSuffixesIdx = containsWgRef(wgWithSuffixes, wg[Ids::identifier].toString()); if (wgSuffixesIdx == -1) continue; const StringArray& wgSuffixes = wgWithSuffixes[wgSuffixesIdx]->wgSuffixes; junctString << wg[Ids::identifier].toString() << wgSuffixes[1]; junctString << " = "; junctString << junct[Ids::identifier].toString() << jTO; junctString << wg[Ids::identifier].toString(); junctString << " : "; junctString << wgWithSuffixes[wgSuffixesIdx]->wgParams[1]; junctString << ";\n\t"; junctString << junct[Ids::identifier].toString() << jTO; junctString << wg[Ids::identifier].toString() << " = "; junctString << junct[Ids::identifier].toString() << jOutputs; junctString << ":(_,!)-"; junctString << wg[Ids::identifier].toString() << wgSuffixes[2]; junctString << ";\n\t"; String jwo; jwo << wg[Ids::identifier].toString() << wgSuffixes[2]; jwo << "*" << wgWithSuffixes[wgSuffixesIdx]->wgParams[0]; junctWgOuts.add(jwo); junctWgParams.add(wgWithSuffixes[wgSuffixesIdx]->wgParams[0]); } String junctLinkString; String junctMassString; // Check if junction has one link and mass connected ValueTree junctLink = getJunctionLink(linkTree, junct); if (junctLink.isValid()) { String jm; if (junctLink[Ids::startVertex] == junct[Ids::identifier]) jm << junctLink[Ids::endVertex].toString(); else jm << junctLink[Ids::startVertex].toString(); junctMassString << jm << "p"; massWithJunct.add(jm); massWithJunctOutputs.add(jm + "p"); linkWithJunct.add(junctLink[Ids::identifier].toString()); ValueTree junctLinkParams = junctLink.getChildWithName(Ids::parameters); StringArray junctLinkParamsStrings; for (int k = 0; k < junctLinkParams.getNumChildren(); ++k) { ValueTree param = junctLinkParams.getChild(k); junctLinkParamsStrings.add(param[Ids::value].toString()); } junctLinkString << "junction" << junctLink.getType().toString(); junctLinkString << "Underneath(0.0,"; junctLinkString << junctLinkParamsStrings.joinIntoString(","); junctLinkString << ")"; // Get mass-like object connected with junction > link ValueTree mwj = massTree.getChildWithProperty(Ids::identifier, jm); String mwjl = "\t"; mwjl << jm; mwjl << " = (0.0"; StringArray otherLinks; for (int k = 0; k < linkTree.getNumChildren(); ++k) { ValueTree li = linkTree.getChild(k); if(li[Ids::identifier].toString() == junctLink[Ids::identifier].toString()) continue; if(li[Ids::startVertex].toString() == jm) { otherLinks.add("-"+li[Ids::identifier].toString()); } else if (li[Ids::endVertex].toString() == jm) { otherLinks.add("+"+li[Ids::identifier].toString()); } } mwjl << otherLinks.joinIntoString(String::empty); mwjl << "+("; mwjl << junct[Ids::identifier].toString() << jOutputs << ":(!,_)))"; // mwjl << " : "; // ValueTree mwjp = mwj.getChildWithName(Ids::parameters); // StringArray mwjpStrings; // for (int p = 0; p < mwjp.getNumChildren(); ++p) // { // ValueTree param = mwjp.getChild(p); // mwjpStrings.add(param[Ids::value].toString()); // } // mwjl << mwj.getType().toString(); // mwjl << "(" << mwjpStrings.joinIntoString(",") << ")"; mwjl << ";"; massWithJunctLine.add(mwjl); } else { junctMassString << "0.0"; junctLinkString << "junctionlink(0.0, 0.0, 0.0, 0.0)"; } junctString << junct[Ids::identifier].toString() << jOutputs; junctString << " = ("; junctString << junctMassString << ", 0.0+"; junctString << junctWgOuts.joinIntoString("+"); junctString << ", 0.0+"; junctString << junctWgParams.joinIntoString("+"); junctString << ") : "; junctString << junctLinkString << ";\n\t"; junctString << junct[Ids::identifier].toString(); junctString << " = "; junctString << junct[Ids::identifier].toString() << jOutputs; junctString << ":(_,!);\n\n"; } //========================================================================== // Write all faustcode //========================================================================== for (int i = 0; i < faustTree.getNumChildren(); ++i) { ValueTree fa = faustTree.getChild(i); dspContent << fa[Ids::identifier].toString(); dspContent << "="; dspContent << fa[Ids::faustCode].toString(); dspContent << ";\n"; } dspContent << "\n"; //========================================================================== // Get all mass names //========================================================================== OwnedArray<MassLinkRef> massLinkRefs; for (int i = 0; i < massTree.getNumChildren(); ++i) { ValueTree ma = massTree.getChild(i); if (massWithJunct.contains(ma[Ids::identifier].toString())) continue; MassLinkRef* mlf = new MassLinkRef(); mlf->massId = ma[Ids::identifier].toString(); StringArray mlfa; mlf->linkRefs = mlfa; if (ma.getType() == Ids::port) mlf->isPort = true; else mlf->isPort = false; massLinkRefs.add(mlf); } //========================================================================== // Write all link-like objects //========================================================================== StringArray linkobjects; for (int i = 0; i < linkTree.getNumChildren(); ++i) { ValueTree li = linkTree.getChild(i); String linkId = li[Ids::identifier].toString(); if (linkWithJunct.contains(linkId)) continue; String startVertex = li[Ids::startVertex].toString(); String endVertex = li[Ids::endVertex].toString(); int sIdx = containsMassLinkRef(massLinkRefs, startVertex); if (sIdx >= 0) massLinkRefs[sIdx]->linkRefs.add("-" + linkId); int eIdx = containsMassLinkRef(massLinkRefs, endVertex); if (eIdx >= 0) massLinkRefs[eIdx]->linkRefs.add("+" + linkId); String tagName = li.getType().toString(); ValueTree params = li.getChildWithName(Ids::parameters); StringArray paramsStr; for (int k = 0; k < params.getNumChildren(); ++k) { ValueTree param = params.getChild(k); paramsStr.add(param[Ids::value].toString()); } //====================================================================== String linkLine; linkLine << "\t"; linkLine << linkId; linkLine << " = ("; linkLine << startVertex << "p - "; linkLine << endVertex << "p) : "; linkLine << tagName << "("; linkLine << paramsStr.joinIntoString(",") << ");"; linkobjects.add(linkLine); //====================================================================== } StringArray massobjects; //========================================================================== // write all mass-like object except those connected to junctions //========================================================================== for (int i = 0; i < massTree.getNumChildren(); ++i) { ValueTree ma = massTree.getChild(i); if (massWithJunct.contains(ma[Ids::identifier].toString())) { if(ma.getType().toString().compare("port") == 0) ++numPorts; continue; } ++numMasslike; String tagName = ma.getType().toString(); String massName = ma[Ids::identifier].toString(); String massLine; massLine << "\t"; massLine << massName << " = (0.0"; if (tagName.compare("port") == 0) ++numPorts; int mIdx = containsMassLinkRef(massLinkRefs, massName); if (mIdx >= 0) { if (massLinkRefs[mIdx]->linkRefs.size() > 0) { massLine << massLinkRefs[mIdx]->linkRefs.joinIntoString(String::empty); } } massLine << ")"; if (tagName.compare("port") != 0) { massLine << " : "; massLine << tagName << "("; ValueTree params = ma.getChildWithName(Ids::parameters); StringArray paramsStr; for (int k = 0; k < params.getNumChildren(); ++k) { ValueTree param = params.getChild(k); paramsStr.add(param[Ids::value].toString()); } massLine << paramsStr.joinIntoString(",") << ")"; } massLine << ";"; massobjects.add(massLine); } //========================================================================== // add remaining mass-like object which are connected to junctions //========================================================================== massobjects.addArray(massWithJunctLine); //========================================================================== // Write all audio objects //========================================================================== StringArray audioobjects; StringArray audioNames; for (int i = 0; i < aoTree.getNumChildren(); ++i) { ValueTree ao = aoTree.getChild(i); String audioLine; String audioName = ao[Ids::identifier].toString(); audioNames.add(audioName); audioLine << "\t"; audioLine << audioName << " = "; ValueTree sources = ao.getChildWithName(Ids::sources); String paramLine; StringArray paramsStr; if (sources.getNumChildren() > 0) { for (int k = 0; k < sources.getNumChildren(); ++k) { ValueTree src = sources.getChild(k); paramsStr.add(src[Ids::value].toString()); } paramLine << paramsStr.joinIntoString("+"); } String optional = ao[Ids::optional].toString(); if (optional != String::empty) { if(! paramLine.startsWith("(")) paramLine = "(" + paramLine; if(! paramLine.endsWith(")")) paramLine << ")"; paramLine << optional; } audioLine << paramLine; audioLine << ";"; audioobjects.add(audioLine); } //========================================================================== // Generate all inputs and outputs //========================================================================== StringArray inputs; StringArray inputsPorts; for (int i = 0; i < massLinkRefs.size(); ++i) { if (massLinkRefs[i]->isPort) inputsPorts.add(massLinkRefs[i]->massId); else inputs.add(massLinkRefs[i]->massId); } StringArray outputs = inputs; outputs.addArray(massWithJunct); StringArray outputsPorts = inputsPorts; StringArray inputsP; StringArray inputsPPorts; for (int i = 0; i < inputs.size(); ++i) { String inputP = inputs[i]; inputP << "p"; inputsP.add(inputP); } for (int i = 0; i < massWithJunctOutputs.size(); ++i) { ++numMasslike; String inputP = massWithJunctOutputs[i]; inputsP.add(inputP); } for (int i = 0; i < inputsPorts.size(); ++i) { String inputPPort = inputsPorts[i]; inputPPort << "p"; inputsPPorts.add(inputPPort); } //========================================================================== // bibBlock with all imputs and outputs //========================================================================== dspContent << "bigBlock(" << inputsP.joinIntoString(","); if (wgInputs.size() > 0) dspContent << "," << wgInputs.joinIntoString(","); if (junctInputs.size() > 0) dspContent << "," << junctInputs.joinIntoString(","); if (inputsPPorts.size() > 0) dspContent << "," << inputsPPorts.joinIntoString(","); dspContent << ") = ("; dspContent << outputs.joinIntoString(","); if (wgOutputs.size() > 0) dspContent << "," << wgOutputs.joinIntoString(","); if (junctOutputs.size() > 0) dspContent << "," << junctOutputs.joinIntoString(","); if (outputsPorts.size() > 0) dspContent << "," << outputsPorts.joinIntoString(","); if (audioNames.size() > 0) dspContent << "," << audioNames.joinIntoString(","); dspContent << ") with {\n"; //========================================================================== // code for model objects //========================================================================== dspContent << "\n\t//waveguide termination objects\n"; dspContent << wgTermString; dspContent << "\t//junctions\n"; dspContent << junctString; dspContent << "\t//mass-like objects\n"; dspContent << massobjects.joinIntoString("\n") << "\n"; dspContent << "\n\t//link-like objects\n"; dspContent << linkobjects.joinIntoString("\n") << "\n"; dspContent << "\n\t//audio objects\n"; dspContent << audioobjects.joinIntoString("\n") << "\n};\n\n"; //========================================================================== // Calculate and write feedback line //========================================================================== StringArray feedbackArray; StringArray outputArray; //TODO: needs to be fixed for latest Synth-A-Modeler changes/fiyes int numFeedback = numMasslike - numPorts + (2 * numWaveguides) + numJunctions; for (int i = 0; i < numFeedback; ++i) { feedbackArray.add("_"); outputArray.add("!"); } for (int i = 0; i < numPorts + audioNames.size(); ++i) { feedbackArray.add("!"); outputArray.add("_"); } dspContent << "process = (bigBlock)~("; dspContent << feedbackArray.joinIntoString(","); dspContent << "):("; dspContent << outputArray.joinIntoString(",") << ");"; //========================================================================== massLinkRefs.clear(); wgWithSuffixes.clear(); return dspContent; }
virtual void menuItemSelected(int menuItemID, int) { if (menuItemID == 200) { WildcardFileFilter wildcardFilter("*.mid", String::empty, "Midi files"); FileBrowserComponent browser(FileBrowserComponent::canSelectFiles | FileBrowserComponent::openMode, lastOpenedFile.exists() ? lastOpenedFile : File(String("C:\\Users\\GeorgeKrueger\\Documents")), &wildcardFilter, nullptr); FileChooserDialogBox dialogBox("Open a midi file", "Please choose a midi file to open...", browser, false, Colours::lightgrey); if (dialogBox.show()) { File selectedFile = browser.getSelectedFile(0); lastOpenedFile = selectedFile; FileInputStream fileStream(selectedFile); juce::MidiFile midiFile; midiFile.readFrom(fileStream); int numTracks = midiFile.getNumTracks(); midiFile.convertTimestampTicksToSeconds(); String msg; msg << "Opened midi file: " << selectedFile.getFileName() << " Tracks: " << numTracks << "\n"; log(msg); for (int i = 0; i < numTracks; ++i) { const MidiMessageSequence* msgSeq = midiFile.getTrack(i); OwnedArray<PluginDescription> results; String plugFile = "C:\\VST\\FMMF.dll"; VSTPluginFormat vstFormat; vstFormat.findAllTypesForFile(results, plugFile); if (results.size() > 0) { msg.clear(); msg << "Found " << results.size() << " plugin(s) matching file " << plugFile << "\n"; log(msg); int secsToRender = 10; double sampleRate = 44100; int totalSizeInSamples = static_cast<int>(44100 * secsToRender); AudioPluginInstance* plugInst = vstFormat.createInstanceFromDescription(*results[0], sampleRate, totalSizeInSamples); if (!plugInst) { msg.clear(); msg << "Failed to load plugin " << plugFile << "\n"; log(msg); continue; } int numInputChannels = plugInst->getTotalNumInputChannels(); int numOutputChannels = plugInst->getTotalNumOutputChannels(); msg.clear(); msg << "Plugin input channels: " << numInputChannels << " output channels: " << numOutputChannels << " Current program: " << plugInst->getCurrentProgram() << "\n"; log(msg); int maxChannels = std::max(numInputChannels, numOutputChannels); AudioBuffer<float> buffer(maxChannels, totalSizeInSamples); MidiBuffer midiMessages; for (int j = 0; j < msgSeq->getNumEvents(); ++j) { MidiMessageSequence::MidiEventHolder* midiEventHolder = msgSeq->getEventPointer(j); MidiMessage midiMsg = midiEventHolder->message; int samplePos = static_cast<int>(midiMsg.getTimeStamp() * sampleRate); midiMessages.addEvent(midiMsg, samplePos); } plugInst->prepareToPlay(sampleRate, totalSizeInSamples); plugInst->processBlock(buffer, midiMessages); /*File txtOutFile("C:\\Users\\GeorgeKrueger\\Documents\\GitHub\\soundserver2\\out.txt"); FileOutputStream* txtOutStream = txtOutFile.createOutputStream(); for (int j = 0; j < 44100; ++j) { float sample = buffer.getSample(0, j); txtOutStream->writeFloat(sample); txtOutStream->writeText(" ", true, false); }*/ File outputFile("C:\\Users\\GeorgeKrueger\\Documents\\GitHub\\soundserver2\\out.wav"); if (outputFile.exists()) { outputFile.deleteFile(); } FileOutputStream* fileOutputStream = outputFile.createOutputStream(); WavAudioFormat wavFormat; StringPairArray metadataValues; juce::AudioFormatWriter* wavFormatWriter = wavFormat.createWriterFor( fileOutputStream, sampleRate, 2, 16, metadataValues, 0); bool writeAudioDataRet = wavFormatWriter->writeFromAudioSampleBuffer(buffer, 0, buffer.getNumSamples()); wavFormatWriter->flush(); msg.clear(); msg << "Done writing to output file " << outputFile.getFileName() << " . Write return value: " << (int)writeAudioDataRet << "\n"; log(msg); delete wavFormatWriter; delete plugInst; } else { msg.clear(); msg << "Could not find plugin from file " << plugFile << "\n"; log(msg); } } } } }
bool update (CodeDocument& document, int lineNum, CodeDocument::Iterator& source, CodeTokeniser* analyser, const int spacesPerTab, const CodeDocument::Position& selectionStart, const CodeDocument::Position& selectionEnd) { OwnedArray <SyntaxToken> newTokens; if (analyser == 0) { newTokens.add (new SyntaxToken (document.getLine (lineNum), -1)); } else if (lineNum < document.getNumLines()) { const CodeDocument::Position pos (&document, lineNum, 0); createTokens (pos.getPosition(), pos.getLineText(), source, analyser, newTokens); } replaceTabsWithSpaces (newTokens, spacesPerTab); int newHighlightStart = 0; int newHighlightEnd = 0; if (selectionStart.getLineNumber() <= lineNum && selectionEnd.getLineNumber() >= lineNum) { const String line (document.getLine (lineNum)); CodeDocument::Position lineStart (&document, lineNum, 0), lineEnd (&document, lineNum + 1, 0); newHighlightStart = indexToColumn (jmax (0, selectionStart.getPosition() - lineStart.getPosition()), line, spacesPerTab); newHighlightEnd = indexToColumn (jmin (lineEnd.getPosition() - lineStart.getPosition(), selectionEnd.getPosition() - lineStart.getPosition()), line, spacesPerTab); } if (newHighlightStart != highlightColumnStart || newHighlightEnd != highlightColumnEnd) { highlightColumnStart = newHighlightStart; highlightColumnEnd = newHighlightEnd; } else { if (tokens.size() == newTokens.size()) { bool allTheSame = true; for (int i = newTokens.size(); --i >= 0;) { if (*tokens.getUnchecked(i) != *newTokens.getUnchecked(i)) { allTheSame = false; break; } } if (allTheSame) return false; } } tokens.swapWithArray (newTokens); return true; }
void UploadWindow::filesDropped(const StringArray& filenames, int mouseX, int mouseY) { StringArray extensions; extensions.addTokens(".jpg;.jpeg;.jpe;.png;.tif;.tiff;.png;.gif;.mpg;.mpeg;.mpe;.mov;.qt;.avi;.wmv", ";", ""); UploadRequest* ur = new UploadRequest(); for (int i = 0; i < filenames.size(); i++) { File imageFile(File::getCurrentWorkingDirectory().getChildFile (filenames[i])); if (imageFile.existsAsFile() && extensions.contains(imageFile.getFileExtension(), true)) { ur->addImageFile(imageFile); } else if (imageFile.isDirectory()) { Array<File> results; imageFile.findChildFiles(results, File::findFiles, true); for (int i = 0; i < results.size(); i++) { if (extensions.contains(results[i].getFileExtension(), true)) ur->addImageFile(results[i]); } } } if (ur->getNumImages() > 0) { Settings* settings = Settings::getInstance(); if (settings->password.isEmpty() || settings->email.isEmpty()) settings->showSettingsDialog(); if (settings->password.isEmpty() || settings->email.isEmpty()) return; if (!smugMug.isLoggedIn()) smugMug.login(Settings::getInstance()->email, Settings::getInstance()->password); if (!smugMug.isLoggedIn()) { AlertWindow::showMessageBox(AlertWindow::WarningIcon, "Komodo Drop", "Error: Unable to connect to Smugmug."); return; } String defaultAlbumName; File root(filenames[0]); if (filenames.size() == 1 && root.isDirectory()) defaultAlbumName = root.getFileName(); else defaultAlbumName = root.getParentDirectory().getFileName(); #ifdef JUCE_DEBUG defaultAlbumName = defaultAlbumName.replaceCharacter('_', ' '); #endif SmugID albumId; bool open = false; if (Settings::getInstance()->silentUpload) { OwnedArray<Album> albums; smugMug.getAlbumList(albums); for (int i = 0; i < albums.size(); i++) { if (albums[i]->title == defaultAlbumName) { albumId = albums[i]->id; break; } } if (albumId.id == -1) { StringPairArray params; albumId = smugMug.createAlbum(defaultAlbumName, 0, params); } ur->setName(defaultAlbumName); } else { bool newAlbum; int catId; String title; StringPairArray params; UploadDialog* ud = new UploadDialog(&smugMug, defaultAlbumName, newAlbum, title, albumId, catId, params, open); if (ud->runModalLoop() == 1) { ur->setName(title); if (newAlbum) albumId = smugMug.createAlbum(title, catId, params); } else { return; } } if (albumId.id != -1) { ur->setOpenBrowser(open); ur->setAlbumId(albumId); smugMug.uploadImages(ur); startTimer(333); repaint(); } else { delete ur; } } else { delete ur; } return; }
void UploadWindow::handleCommand(int res) { if (res == 1) { if (!smugMug.isUploading() || AlertWindow::showOkCancelBox(AlertWindow::InfoIcon, "Komodo Drop", "There is an upload in progress, quit anyway?") == 1) { JUCEApplication::quit(); } } else if (res == 2) { Settings::getInstance()->showSettingsDialog(); } else if (res == 3) { AlertWindow::showMessageBox(AlertWindow::InfoIcon, "Komodo Drop " + JUCEApplication::getInstance()->getApplicationVersion(), "Created By: Roland Rabien ([email protected])\nBased on JUCE (www.rawmaterialsoftware.com)"); } else if (res == 4) { setVisible(!isVisible()); } else if (res == 5) { if (!smugMug.isLoggedIn()) smugMug.login(Settings::getInstance()->email, Settings::getInstance()->password); OwnedArray<Album> albums; smugMug.getAlbumList(albums); if (albums.size() > 0) { ComboBox* album = new ComboBox(""); album->setSize(300, 26); album->setVisible(true); for (int i = 0; i < albums.size(); i++) album->addItem(albums[i]->getDisplayTitle(), i + 1); album->setSelectedItemIndex(0); AlertWindow aw("Komodo Drop", "Delete album:", AlertWindow::InfoIcon); aw.addCustomComponent(album); aw.addButton("ok", 1); aw.addButton("cancel", 2); if (aw.runModalLoop() == 1) { smugMug.deleteAlbum(albums[album->getSelectedId() - 1]->id); } delete album; } } else if (res == 6) { if (!smugMug.isLoggedIn()) smugMug.login(Settings::getInstance()->email, Settings::getInstance()->password); OwnedArray<Category> categories; smugMug.getCategoryList(categories); if (categories.size()) { ComboBox* cats = new ComboBox(""); cats->setSize(300, 26); cats->setVisible(true); for (int i = 0; i < categories.size(); i++) cats->addItem(categories[i]->title, categories[i]->id + 1); cats->setSelectedItemIndex(0); AlertWindow aw("Komodo Drop", "Delete category:", AlertWindow::InfoIcon); aw.addCustomComponent(cats); aw.addButton("ok", 1); aw.addButton("cancel", 2); if (aw.runModalLoop() == 1) { smugMug.deleteCategory(cats->getSelectedId() - 1); } delete cats; } } else if (res == 7) { if (!smugMug.isLoggedIn()) smugMug.login(Settings::getInstance()->email, Settings::getInstance()->password); OwnedArray<Category> categories; smugMug.getCategoryList(categories); OwnedArray<SubCategory> subCategories; smugMug.getSubCategoryList(subCategories); if (subCategories.size()) { ComboBox* cats = new ComboBox(""); cats->setSize(300, 26); cats->setVisible(true); for (int i = 0; i < subCategories.size(); i++) { int j; for (j = 0; j < categories.size(); j++) { if (categories[j]->id == subCategories[i]->parentId) break; } cats->addItem(categories[j]->title + " >> " + subCategories[i]->title, subCategories[i]->id + 1); } cats->setSelectedItemIndex(0); AlertWindow aw("Komodo Drop", "Delete sub category:", AlertWindow::InfoIcon); aw.addCustomComponent(cats); aw.addButton("ok", 1); aw.addButton("cancel", 2); if (aw.runModalLoop() == 1) { smugMug.deleteSubCategory(cats->getSelectedId() - 1); } delete cats; } } else if (res == 8) { if (!smugMug.isLoggedIn()) smugMug.login(Settings::getInstance()->email, Settings::getInstance()->password); AlertWindow aw("Komodo Drop", "Create category:", AlertWindow::InfoIcon); aw.addTextEditor("name", "", "category name:"); aw.addButton("ok", 1); aw.addButton("cancel", 2); if (aw.runModalLoop() == 1 && aw.getTextEditorContents("name").isNotEmpty()) { smugMug.createCategory(aw.getTextEditorContents("name")); } } else if (res == 9) { if (!smugMug.isLoggedIn()) smugMug.login(Settings::getInstance()->email, Settings::getInstance()->password); OwnedArray<Category> categories; smugMug.getCategoryList(categories); if (categories.size()) { ComboBox* cats = new ComboBox(""); cats->setSize(300, 26); cats->setVisible(true); for (int i = 0; i < categories.size(); i++) cats->addItem(categories[i]->title, categories[i]->id + 1); cats->setSelectedItemIndex(0); AlertWindow aw("Komodo Drop", "Create sub category:", AlertWindow::InfoIcon); aw.addCustomComponent(cats); aw.addTextEditor("name", "", "sub category name:"); aw.addButton("ok", 1); aw.addButton("cancel", 2); if (aw.runModalLoop() == 1 && aw.getTextEditorContents("name").isNotEmpty()) { smugMug.createSubCategory(cats->getSelectedId() - 1, aw.getTextEditorContents("name")); } delete cats; } } else if (res == 10) { smugMug.cancelUploads(); } else if (res == 11) { FileChooser fc("Komodo Drop", File::getSpecialLocation(File::userDocumentsDirectory)); if (fc.browseForMultipleFilesToOpen()) { const Array<File>& files = fc.getResults(); StringArray names; for (int i = 0; i < files.size(); i++) names.add(files[i].getFullPathName()); filesDropped(names, 0, 0); } } else if (res == 12) { FileChooser fc("Komodo Drop", File::getSpecialLocation(File::userDocumentsDirectory)); if (fc.browseForDirectory()) { File dir = fc.getResult(); Array<File> files; StringArray names; dir.findChildFiles(files, File::findFiles, false); for (int i = 0; i < files.size(); i++) names.add(files[i].getFullPathName()); if (names.size()) filesDropped(names, 0, 0); } } else if (res == 13) { FileChooser fc("Komodo Drop", File::getSpecialLocation(File::userDocumentsDirectory)); if (fc.browseForDirectory()) { File dir = fc.getResult(); Array<File> files; StringArray names; dir.findChildFiles(files, File::findFiles, true); for (int i = 0; i < files.size(); i++) names.add(files[i].getFullPathName()); if (names.size()) filesDropped(names, 0, 0); } } else if (res == 19) { FileChooser fc("Komodo Drop", File::getSpecialLocation(File::userDocumentsDirectory)); if (fc.browseForDirectory()) { File dir = fc.getResult(); Array<File> folders; dir.findChildFiles(folders, File::findDirectories, false); for (int i = 0; i < folders.size(); i++) { Array<File> files; folders[i].findChildFiles(files, File::findFiles, true); StringArray names; for (int j = 0; j < files.size(); j++) names.add(files[j].getFullPathName()); if (names.size()) filesDropped(names, 0, 0); } } } else if (res == 14) { smugMug.showLogFile(); } else if (res == 15) { smugMug.clearLogFile(); } else if (res == 16) { if (!smugMug.isLoggedIn()) smugMug.login(Settings::getInstance()->email, Settings::getInstance()->password); OwnedArray<Album> albums; smugMug.getAlbumList(albums); if (albums.size() > 0) { ComboBox* album = new ComboBox(""); album->setSize(300, 26); album->setVisible(true); for (int i = 0; i < albums.size(); i++) album->addItem(albums[i]->getDisplayTitle(), i + 1); album->setSelectedItemIndex(0); AlertWindow aw("Komodo Drop", "Delete duplicate images from album:", AlertWindow::InfoIcon); aw.addCustomComponent(album); aw.addButton("ok", 1); aw.addButton("cancel", 2); if (aw.runModalLoop() == 1) { smugMug.deleteDuplicates(albums[album->getSelectedId() - 1]->id); } delete album; } } else if (res == 17) { smugMug.showQueue(); } else if (res == 18) { if (!smugMug.isLoggedIn()) smugMug.login(Settings::getInstance()->email, Settings::getInstance()->password); smugMug.showTopPhotos(); } }