static float getAverageY (const Font& font, const char* chars, bool getTop)
{
GlyphArrangement ga;
ga.addLineOfText (font, chars, 0, 0);
Array<float> y;
DefaultElementComparator<float> sorter;
for (int i = 0; i < ga.getNumGlyphs(); ++i)
{
Path p;
ga.getGlyph (i).createPath (p);
Rectangle<float> bounds (p.getBounds());
if (! p.isEmpty())
y.addSorted (sorter, getTop ? bounds.getY() : bounds.getBottom());
}
float median = y[y.size() / 2];
float total = 0;
int num = 0;
for (int i = 0; i < y.size(); ++i)
{
if (std::abs (median - y.getUnchecked(i)) < 0.05f * (float) standardHeight)
{
total += y.getUnchecked(i);
++num;
}
}
return num < 4 ? 0.0f : total / (num * (float) standardHeight);
}
//==============================================================================
void AudioDeviceManager::setDefaultMidiOutput (const String& deviceName)
{
if (defaultMidiOutputName != deviceName)
{
Array <AudioIODeviceCallback*> oldCallbacks;
{
const ScopedLock sl (audioCallbackLock);
oldCallbacks = callbacks;
callbacks.clear();
}
if (currentAudioDevice != nullptr)
for (int i = oldCallbacks.size(); --i >= 0;)
oldCallbacks.getUnchecked(i)->audioDeviceStopped();
defaultMidiOutput = nullptr;
defaultMidiOutputName = deviceName;
if (deviceName.isNotEmpty())
defaultMidiOutput = MidiOutput::openDevice (MidiOutput::getDevices().indexOf (deviceName));
if (currentAudioDevice != nullptr)
for (int i = oldCallbacks.size(); --i >= 0;)
oldCallbacks.getUnchecked(i)->audioDeviceAboutToStart (currentAudioDevice);
{
const ScopedLock sl (audioCallbackLock);
callbacks = oldCallbacks;
}
updateXml();
sendChangeMessage();
}
}
void UnitTestRunner::runTests (const Array<UnitTest*>& tests, int64 randomSeed)
{
results.clear();
resultsUpdated();
if (randomSeed == 0)
randomSeed = Random().nextInt (0x7ffffff);
randomForTest = Random (randomSeed);
logMessage ("Random seed: 0x" + String::toHexString (randomSeed));
for (int i = 0; i < tests.size(); ++i)
{
if (shouldAbortTests())
break;
#if JUCE_EXCEPTIONS_DISABLED
tests.getUnchecked(i)->performTest (this);
#else
try
{
tests.getUnchecked(i)->performTest (this);
}
catch (...)
{
addFail ("An unhandled exception was thrown!");
}
#endif
}
endTest();
}
PluginWindow* PluginWindow::getWindowFor (AudioProcessorGraph::Node* node,
bool useGenericView)
{
for (int i = activePluginWindows.size(); --i >= 0;)
if (activePluginWindows.getUnchecked(i)->owner == node
&& activePluginWindows.getUnchecked(i)->isGeneric == useGenericView)
return activePluginWindows.getUnchecked(i);
AudioProcessorEditor* ui = nullptr;
if (! useGenericView)
{
ui = node->getProcessor()->createEditorIfNeeded();
if (ui == nullptr)
useGenericView = true;
}
if (useGenericView)
{
ui = new GenericAudioProcessorEditor (node->getProcessor());
}
if (ui != nullptr)
{
AudioPluginInstance* const plugin = dynamic_cast <AudioPluginInstance*> (node->getProcessor());
if (plugin != nullptr)
ui->setName (plugin->getName());
return new PluginWindow (ui, node, useGenericView);
}
return nullptr;
}
void Mcfx_convolverAudioProcessor::LoadPresetByName(String presetName)
{
Array <File> files;
presetDir.findChildFiles(files, File::findFiles, true, presetName);
if (files.size())
{
LoadConfiguration(files.getUnchecked(0)); // Load first result
box_preset_str = files.getUnchecked(0).getFileNameWithoutExtension();
}
}
SynthesiserVoice* Synthesiser::findVoiceToSteal (SynthesiserSound* soundToPlay,
int /*midiChannel*/, int midiNoteNumber) const
{
SynthesiserVoice* bottom = nullptr;
SynthesiserVoice* top = nullptr;
// this is a list of voices we can steal, sorted by how long they've been running
Array<SynthesiserVoice*> usableVoices;
usableVoices.ensureStorageAllocated (voices.size());
for (int i = 0; i < voices.size(); ++i)
{
SynthesiserVoice* const voice = voices.getUnchecked (i);
if (voice->canPlaySound (soundToPlay))
{
VoiceAgeSorter sorter;
usableVoices.addSorted (sorter, voice);
const int note = voice->getCurrentlyPlayingNote();
if (bottom == nullptr || note < bottom->getCurrentlyPlayingNote())
bottom = voice;
if (top == nullptr || note > top->getCurrentlyPlayingNote())
top = voice;
}
}
jassert (bottom != nullptr && top != nullptr);
// The oldest note that's playing with the target pitch playing is ideal..
for (int i = 0; i < usableVoices.size(); ++i)
{
SynthesiserVoice* const voice = usableVoices.getUnchecked (i);
if (voice->getCurrentlyPlayingNote() == midiNoteNumber)
return voice;
}
// ..otherwise, look for the oldest note that isn't the top or bottom note..
for (int i = 0; i < usableVoices.size(); ++i)
{
SynthesiserVoice* const voice = usableVoices.getUnchecked (i);
if (voice != bottom && voice != top)
return voice;
}
// ..otherwise, there's only one or two voices to choose from - we'll return the top one..
return top;
}
int S2MP::indexOfMax(Array<double>& weights)
{
int mx = 0;
for (int i = 1; i < weights.size(); i++)
{
if(weights.getUnchecked(mx) < weights.getUnchecked(i))
{
mx = i;
}
}
return mx;
}
void PluginWindow::updateWindow(AudioProcessorGraph::Node* node, int nodeId)
{
for (int i = activePluginWindows.size(); --i >= 0;)
if (activePluginWindows.getUnchecked(i)->owner->nodeId == nodeId)
{
AudioProcessorEditor* ui = nullptr;
activePluginWindows.getUnchecked(i)->setContentOwned(nullptr, false);
ui = node->getProcessor()->createEditor();
if(ui)
activePluginWindows.getUnchecked(i)->setContentOwned(ui, true);
activePluginWindows.getUnchecked(i)->repaint();
}
}
void ComponentBuilder::updateChildComponents (Component& parent, const ValueTree& children)
{
using namespace ComponentBuilderHelpers;
const int numExistingChildComps = parent.getNumChildComponents();
Array <Component*> componentsInOrder;
componentsInOrder.ensureStorageAllocated (numExistingChildComps);
{
OwnedArray<Component> existingComponents;
existingComponents.ensureStorageAllocated (numExistingChildComps);
int i;
for (i = 0; i < numExistingChildComps; ++i)
existingComponents.add (parent.getChildComponent (i));
const int newNumChildren = children.getNumChildren();
for (i = 0; i < newNumChildren; ++i)
{
const ValueTree childState (children.getChild (i));
ComponentBuilder::TypeHandler* const type = getHandlerForState (childState);
jassert (type != nullptr);
if (type != nullptr)
{
Component* c = findComponentWithID (existingComponents, getStateId (childState));
if (c == nullptr)
c = createNewComponent (*type, childState, &parent);
componentsInOrder.add (c);
}
}
// (remaining unused items in existingComponents get deleted here as it goes out of scope)
}
// Make sure the z-order is correct..
if (componentsInOrder.size() > 0)
{
componentsInOrder.getLast()->toFront (false);
for (int i = componentsInOrder.size() - 1; --i >= 0;)
componentsInOrder.getUnchecked(i)->toBehind (componentsInOrder.getUnchecked (i + 1));
}
}
bool MainWindow::shouldDropFilesWhenDraggedExternally (const DragAndDropTarget::SourceDetails& sourceDetails,
StringArray& files, bool& canMoveFiles)
{
if (TreeView* tv = dynamic_cast<TreeView*> (sourceDetails.sourceComponent.get()))
{
Array<JucerTreeViewBase*> selected;
for (int i = tv->getNumSelectedItems(); --i >= 0;)
if (JucerTreeViewBase* b = dynamic_cast<JucerTreeViewBase*> (tv->getSelectedItem(i)))
selected.add (b);
if (selected.size() > 0)
{
for (int i = selected.size(); --i >= 0;)
{
if (JucerTreeViewBase* jtvb = selected.getUnchecked(i))
{
const File f (jtvb->getDraggableFile());
if (f.existsAsFile())
files.add (f.getFullPathName());
}
}
canMoveFiles = false;
return files.size() > 0;
}
}
return false;
}
static void findAllFocusableComponents (Component* const parent, Array <Component*>& comps)
{
if (parent->getNumChildComponents() > 0)
{
Array <Component*> localComps;
ScreenPositionComparator comparator;
for (int i = parent->getNumChildComponents(); --i >= 0;)
{
Component* const c = parent->getChildComponent (i);
if (c->isVisible() && c->isEnabled())
localComps.addSorted (comparator, c);
}
for (int i = 0; i < localComps.size(); ++i)
{
Component* const c = localComps.getUnchecked (i);
if (c->getWantsKeyboardFocus())
comps.add (c);
if (! c->isFocusContainer())
findAllFocusableComponents (c, comps);
}
}
}
void DeletedAtShutdown::deleteAll()
{
// make a local copy of the array, so it can't get into a loop if something
// creates another DeletedAtShutdown object during its destructor.
Array <DeletedAtShutdown*> localCopy;
{
const SpinLock::ScopedLockType sl (deletedAtShutdownLock);
localCopy = getObjects();
}
for (int i = localCopy.size(); --i >= 0;)
{
JUCE_TRY
{
DeletedAtShutdown* deletee = localCopy.getUnchecked(i);
// double-check that it's not already been deleted during another object's destructor.
{
const SpinLock::ScopedLockType sl (deletedAtShutdownLock);
if (! getObjects().contains (deletee))
deletee = nullptr;
}
delete deletee;
}
JUCE_CATCH_EXCEPTION
}
// if no objects got re-created during shutdown, this should have been emptied by their
// destructors
jassert (getObjects().size() == 0);
getObjects().clear(); // just to make sure the array doesn't have any memory still allocated
}
void CodeDocument::insert (const String& text, const int insertPos, const bool undoable)
{
if (text.isNotEmpty())
{
if (undoable)
{
undoManager.perform (new CodeDocumentInsertAction (*this, text, insertPos));
}
else
{
Position pos (*this, insertPos);
const int firstAffectedLine = pos.getLineNumber();
CodeDocumentLine* const firstLine = lines [firstAffectedLine];
String textInsideOriginalLine (text);
if (firstLine != nullptr)
{
const int index = pos.getIndexInLine();
textInsideOriginalLine = firstLine->line.substring (0, index)
+ textInsideOriginalLine
+ firstLine->line.substring (index);
}
maximumLineLength = -1;
Array <CodeDocumentLine*> newLines;
CodeDocumentLine::createLines (newLines, textInsideOriginalLine);
jassert (newLines.size() > 0);
CodeDocumentLine* const newFirstLine = newLines.getUnchecked (0);
newFirstLine->lineStartInFile = firstLine != nullptr ? firstLine->lineStartInFile : 0;
lines.set (firstAffectedLine, newFirstLine);
if (newLines.size() > 1)
lines.insertArray (firstAffectedLine + 1, newLines.getRawDataPointer() + 1, newLines.size() - 1);
int lineStart = newFirstLine->lineStartInFile;
for (int i = firstAffectedLine; i < lines.size(); ++i)
{
CodeDocumentLine& l = *lines.getUnchecked (i);
l.lineStartInFile = lineStart;
lineStart += l.lineLength;
}
checkLastLineStatus();
const int newTextLength = text.length();
for (int i = 0; i < positionsToMaintain.size(); ++i)
{
CodeDocument::Position& p = *positionsToMaintain.getUnchecked(i);
if (p.getPosition() >= insertPos)
p.setPosition (p.getPosition() + newTextLength);
}
listeners.call (&CodeDocument::Listener::codeDocumentTextInserted, text, insertPos);
}
}
}
bool ThreadPool::removeAllJobs (const bool interruptRunningJobs, const int timeOutMs,
ThreadPool::JobSelector* selectedJobsToRemove)
{
Array <ThreadPoolJob*> jobsToWaitFor;
{
OwnedArray<ThreadPoolJob> deletionList;
{
const ScopedLock sl (lock);
for (int i = jobs.size(); --i >= 0;)
{
ThreadPoolJob* const job = jobs.getUnchecked(i);
if (selectedJobsToRemove == nullptr || selectedJobsToRemove->isJobSuitable (job))
{
if (job->isActive)
{
jobsToWaitFor.add (job);
if (interruptRunningJobs)
job->signalJobShouldExit();
}
else
{
jobs.remove (i);
addToDeleteList (deletionList, job);
}
}
}
}
}
const uint32 start = Time::getMillisecondCounter();
for (;;)
{
for (int i = jobsToWaitFor.size(); --i >= 0;)
{
ThreadPoolJob* const job = jobsToWaitFor.getUnchecked (i);
if (! isJobRunning (job))
jobsToWaitFor.remove (i);
}
if (jobsToWaitFor.size() == 0)
break;
if (timeOutMs >= 0 && Time::getMillisecondCounter() >= start + timeOutMs)
return false;
jobFinishedSignal.wait (20);
}
return true;
}
void GlyphArrangement::addCurtailedLineOfText (const Font& font,
const String& text,
const float xOffset,
const float yOffset,
const float maxWidthPixels,
const bool useEllipsis)
{
if (text.isNotEmpty())
{
Array <int> newGlyphs;
Array <float> xOffsets;
font.getGlyphPositions (text, newGlyphs, xOffsets);
const int textLen = newGlyphs.size();
glyphs.ensureStorageAllocated (glyphs.size() + textLen);
String::CharPointerType t (text.getCharPointer());
for (int i = 0; i < textLen; ++i)
{
const float thisX = xOffsets.getUnchecked (i);
const float nextX = xOffsets.getUnchecked (i + 1);
if (nextX > maxWidthPixels + 1.0f)
{
// curtail the string if it's too wide..
if (useEllipsis && textLen > 3 && glyphs.size() >= 3)
insertEllipsis (font, xOffset + maxWidthPixels, 0, glyphs.size());
break;
}
else
{
const bool isWhitespace = t.isWhitespace();
glyphs.add (new PositionedGlyph (font, t.getAndAdvance(),
newGlyphs.getUnchecked(i),
xOffset + thisX, yOffset,
nextX - thisX, isWhitespace));
}
}
}
}
void Toolbar::addDefaultItems (ToolbarItemFactory& factoryToUse)
{
Array <int> ids;
factoryToUse.getDefaultItemSet (ids);
clear();
for (int i = 0; i < ids.size(); ++i)
addItemInternal (factoryToUse, ids.getUnchecked (i), -1);
resized();
}
ComponentPeer* ComponentPeer::getPeerFor (const Component* const component) noexcept
{
for (int i = heavyweightPeers.size(); --i >= 0;)
{
ComponentPeer* const peer = heavyweightPeers.getUnchecked(i);
if (peer->getComponent() == component)
return peer;
}
return nullptr;
}
OpenGLContext* OpenGLContext::getCurrentContext()
{
for (int i = knownContexts.size(); --i >= 0;)
{
OpenGLContext* const oglc = knownContexts.getUnchecked(i);
if (oglc->isActive())
return oglc;
}
return nullptr;
}
void PluginWindow::closeAllCurrentlyOpenWindows()
{
if (activePluginWindows.size() > 0)
{
for (int i = activePluginWindows.size(); --i >= 0;)
delete activePluginWindows.getUnchecked (i);
Component dummyModalComp;
dummyModalComp.enterModalState();
MessageManager::getInstance()->runDispatchLoopUntil (50);
}
}
void Project::BuildConfiguration::createPropertyEditors (Array <PropertyComponent*>& props)
{
props.add (new TextPropertyComponent (getName(), "Name", 96, false));
props.getLast()->setTooltip ("The name of this configuration.");
props.add (new BooleanPropertyComponent (isDebug(), "Debug mode", "Debugging enabled"));
props.getLast()->setTooltip ("If enabled, this means that the configuration should be built with debug synbols.");
const char* optimisationLevels[] = { "No optimisation", "Optimise for size and speed", "Optimise for maximum speed", 0 };
const int optimisationLevelValues[] = { 1, 2, 3, 0 };
props.add (new ChoicePropertyComponent (getOptimisationLevel(), "Optimisation", StringArray (optimisationLevels), Array<var> (optimisationLevelValues)));
props.getLast()->setTooltip ("The optimisation level for this configuration");
props.add (new TextPropertyComponent (getTargetBinaryName(), "Binary name", 256, false));
props.getLast()->setTooltip ("The filename to use for the destination binary executable file. Don't add a suffix to this, because platform-specific suffixes will be added for each target platform.");
props.add (new TextPropertyComponent (getTargetBinaryRelativePath(), "Binary location", 1024, false));
props.getLast()->setTooltip ("The folder in which the finished binary should be placed. Leave this blank to cause the binary to be placed in its default location in the build folder.");
props.add (new TextPropertyComponent (getHeaderSearchPath(), "Header search path", 16384, false));
props.getLast()->setTooltip ("Extra header search paths. Use semi-colons to separate multiple paths.");
props.add (new TextPropertyComponent (getBuildConfigPreprocessorDefs(), "Preprocessor definitions", 32768, false));
props.getLast()->setTooltip ("Extra preprocessor definitions. Use the form \"NAME1=value NAME2=value\", using whitespace or commas to separate the items - to include a space or comma in a definition, precede it with a backslash.");
if (getMacSDKVersion().toString().isEmpty())
getMacSDKVersion() = osxVersionDefault;
const char* osxVersions[] = { "Use Default", osxVersion10_4, osxVersion10_5, osxVersion10_6, 0 };
const char* osxVersionValues[] = { osxVersionDefault, osxVersion10_4, osxVersion10_5, osxVersion10_6, 0 };
props.add (new ChoicePropertyComponent (getMacSDKVersion(), "OSX Base SDK Version", StringArray (osxVersions), Array<var> (osxVersionValues)));
props.getLast()->setTooltip ("The version of OSX to link against in the XCode build.");
if (getMacCompatibilityVersion().toString().isEmpty())
getMacCompatibilityVersion() = osxVersionDefault;
props.add (new ChoicePropertyComponent (getMacCompatibilityVersion(), "OSX Compatibility Version", StringArray (osxVersions), Array<var> (osxVersionValues)));
props.getLast()->setTooltip ("The minimum version of OSX that the target binary will be compatible with.");
const char* osxArch[] = { "Use Default", "Native architecture of build machine", "Universal Binary (32-bit)", "Universal Binary (64-bit)", "64-bit Intel", 0 };
const char* osxArchValues[] = { osxArch_Default, osxArch_Native, osxArch_32BitUniversal, osxArch_64BitUniversal, osxArch_64Bit, 0 };
if (getMacArchitecture().toString().isEmpty())
getMacArchitecture() = osxArch_Default;
props.add (new ChoicePropertyComponent (getMacArchitecture(), "OSX Architecture", StringArray (osxArch), Array<var> (osxArchValues)));
props.getLast()->setTooltip ("The type of OSX binary that will be produced.");
for (int i = props.size(); --i >= 0;)
props.getUnchecked(i)->setPreferredHeight (22);
}
PluginWindow* PluginWindow::getWindowFor (AudioProcessorGraph::Node* const node,
WindowFormatType type)
{
jassert (node != nullptr);
for (int i = activePluginWindows.size(); --i >= 0;)
if (activePluginWindows.getUnchecked(i)->owner == node
&& activePluginWindows.getUnchecked(i)->type == type)
return activePluginWindows.getUnchecked(i);
AudioProcessor* processor = node->getProcessor();
AudioProcessorEditor* ui = nullptr;
if (type == Normal)
{
ui = processor->createEditorIfNeeded();
if (ui == nullptr)
type = Generic;
}
if (ui == nullptr)
{
//if (type == Generic || type == Parameters)
//ui = new PMixGenericAudioProcessorEditor (processor);
// else if (type == Programs)
// ui = new ProgramAudioProcessorEditor (processor);
}
if (ui != nullptr)
{
if (AudioPluginInstance* const plugin = dynamic_cast<AudioPluginInstance*> (processor))
ui->setName (plugin->getName());
return new PluginWindow (ui, node, type);
}
return nullptr;
}
static void writeHeader (ValueTreeSynchroniser& target, MemoryOutputStream& stream,
ChangeType type, ValueTree v)
{
writeHeader (stream, type);
Array<int> path;
getValueTreePath (v, target.getRoot(), path);
stream.writeCompressedInt (path.size());
for (int i = path.size(); --i >= 0;)
stream.writeCompressedInt (path.getUnchecked(i));
}
void growRangeAll (const int start, const int end, int spaceDiff) noexcept
{
Array<Panel*> expandableItems;
for (int i = start; i < end; ++i)
if (get(i).canExpand() && ! get(i).isMinimised())
expandableItems.add (& get(i));
for (int attempts = 4; --attempts >= 0 && spaceDiff > 0;)
for (int i = expandableItems.size(); --i >= 0 && spaceDiff > 0;)
spaceDiff -= expandableItems.getUnchecked(i)->expand (spaceDiff / (i + 1));
growRangeLast (start, end, spaceDiff);
}
ToolbarItemPalette::ToolbarItemPalette (ToolbarItemFactory& tbf, Toolbar& bar)
: factory (tbf), toolbar (bar)
{
Component* const itemHolder = new Component();
viewport.setViewedComponent (itemHolder);
Array<int> allIds;
factory.getAllToolbarItemIds (allIds);
for (int i = 0; i < allIds.size(); ++i)
addComponent (allIds.getUnchecked (i), -1);
addAndMakeVisible (viewport);
}
//==============================================================================
double PitchDetector::detectPitch (float* samples, int numSamples) noexcept
{
Array<double> pitches;
pitches.ensureStorageAllocated (int (numSamples / numSamplesNeededForDetection));
while (numSamples >= numSamplesNeededForDetection)
{
double pitch = detectPitchForBlock (samples, numSamplesNeededForDetection);//0.0;
if (pitch > 0.0)
pitches.add (pitch);
numSamples -= numSamplesNeededForDetection;
samples += numSamplesNeededForDetection;
}
if (pitches.size() == 1)
{
return pitches[0];
}
else if (pitches.size() > 1)
{
DefaultElementComparator<double> sorter;
pitches.sort (sorter);
const double stdDev = findStandardDeviation (pitches.getRawDataPointer(), pitches.size());
const double medianSample = findMedian (pitches.getRawDataPointer(), pitches.size());
const double lowerLimit = medianSample - stdDev;
const double upperLimit = medianSample + stdDev;
Array<double> correctedPitches;
correctedPitches.ensureStorageAllocated (pitches.size());
for (int i = 0; i < pitches.size(); ++i)
{
const double pitch = pitches.getUnchecked (i);
if (pitch >= lowerLimit && pitch <= upperLimit)
correctedPitches.add (pitch);
}
const double finalPitch = findMean (correctedPitches.getRawDataPointer(), correctedPitches.size());
return finalPitch;
}
return 0.0;
}
void ApplicationCommandManager::registerAllCommandsForTarget (ApplicationCommandTarget* target)
{
if (target != nullptr)
{
Array<CommandID> commandIDs;
target->getAllCommands (commandIDs);
for (int i = 0; i < commandIDs.size(); ++i)
{
ApplicationCommandInfo info (commandIDs.getUnchecked(i));
target->getCommandInfo (info.commandID, info);
registerCommand (info);
}
}
}
void UnitTestRunner::runTests (const Array<UnitTest*>& tests, const bool assertOnFailure_)
{
results.clear();
assertOnFailure = assertOnFailure_;
resultsUpdated();
for (int i = 0; i < tests.size(); ++i)
{
try
{
tests.getUnchecked(i)->performTest (this);
}
catch (...)
{
addFail ("An unhandled exception was thrown!");
}
}
endTest();
}
void MessageManager::broadcastMessage (const String& value)
{
const String localCopy (value);
Array<HWND> windows;
EnumWindows (&WindowsMessageHelpers::broadcastEnumWindowProc, (LPARAM) &windows);
for (int i = windows.size(); --i >= 0;)
{
COPYDATASTRUCT data;
data.dwData = WindowsMessageHelpers::broadcastMessageMagicNumber;
data.cbData = (localCopy.length() + 1) * sizeof (CharPointer_UTF32::CharType);
data.lpData = (void*) localCopy.toUTF32().getAddress();
DWORD_PTR result;
SendMessageTimeout (windows.getUnchecked (i), WM_COPYDATA,
(WPARAM) juce_messageWindowHandle,
(LPARAM) &data,
SMTO_BLOCK | SMTO_ABORTIFHUNG, 8000, &result);
}
}
void UnitTestRunner::runTests (const Array<UnitTest*>& tests)
{
results.clear();
resultsUpdated();
for (int i = 0; i < tests.size(); ++i)
{
if (shouldAbortTests())
break;
try
{
tests.getUnchecked(i)->performTest (this);
}
catch (...)
{
addFail ("An unhandled exception was thrown!");
}
}
endTest();
}
BEGIN_JUCE_NAMESPACE
#include "juce_ToolbarItemPalette.h"
#include "juce_ToolbarItemFactory.h"
//==============================================================================
ToolbarItemPalette::ToolbarItemPalette (ToolbarItemFactory& factory_,
Toolbar* const toolbar_)
: factory (factory_),
toolbar (toolbar_)
{
Component* const itemHolder = new Component();
viewport.setViewedComponent (itemHolder);
Array <int> allIds;
factory.getAllToolbarItemIds (allIds);
for (int i = 0; i < allIds.size(); ++i)
addComponent (allIds.getUnchecked (i), -1);
addAndMakeVisible (&viewport);
}
